X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue-server.py;h=72e0fdb7225504833e7772a03919836b3d88dda0;hb=7543a2420dd05a73aa8f6569ecd4a8517873cebb;hp=0c82f05996e8bd6f6e0307305ea1b96323a59621;hpb=5797646d53448d99a5d6c0e031b16e8ee78a8edb;p=plomrogue diff --git a/plomrogue-server.py b/plomrogue-server.py index 0c82f05..72e0fdb 100755 --- a/plomrogue-server.py +++ b/plomrogue-server.py @@ -6,6 +6,13 @@ import shutil import time +def strong_write(file, string): + """Apply write(string), flush(), and os.fsync() to file.""" + file.write(string) + file.flush() + os.fsync(file) + + def setup_server_io(): """Fill IO files DB with proper file( path)s. Write process IO test string. @@ -25,8 +32,7 @@ def setup_server_io(): io_db["teststring"] = str(os.getpid()) + " " + str(time.time()) os.makedirs(io_db["path_server"], exist_ok=True) io_db["file_out"] = open(io_db["path_out"], "w") - io_db["file_out"].write(io_db["teststring"] + "\n") - io_db["file_out"].flush() + strong_write(io_db["file_out"], io_db["teststring"] + "\n") if os.access(io_db["path_in"], os.F_OK): os.remove(io_db["path_in"]) io_db["file_in"] = open(io_db["path_in"], "w") @@ -54,10 +60,11 @@ def cleanup_server_io(): def obey(command, prefix, replay=False, do_record=False): """Call function from commands_db mapped to command's first token. - 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. If not, and do do_record is set, - non-meta commands are recorded via record(), and save_world() is called. + Tokenize command string with 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. If not, non-meta commands set + io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if + do_record is set, 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. """ @@ -71,7 +78,7 @@ def obey(command, prefix, replay=False, do_record=False): if len(tokens) > 0 and tokens[0] in commands_db \ and len(tokens) == commands_db[tokens[0]][0] + 1: if commands_db[tokens[0]][1]: - commands_db[tokens[0]][2]() + commands_db[tokens[0]][2](*tokens[1:]) elif replay: print("Due to replay mode, reading command as 'go on in record'.") line = io_db["file_record"].readline() @@ -86,7 +93,8 @@ def obey(command, prefix, replay=False, do_record=False): if do_record: record(command) save_world() - else: + io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"] + elif 0 != len(tokens): print("Invalid command/argument, or bad number of tokens.") @@ -99,9 +107,7 @@ def atomic_write(path, text, do_append=False): 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()) + strong_write(file, text) file.close() if os.access(path, os.F_OK): os.remove(path) @@ -117,38 +123,66 @@ def record(command): def save_world(): - # Dummy for saving all commands to reconstruct current world state. - # Misses same optimizations as record() from the original record(). - ta_string = "" - for id in world_db["ThingActions"]: - ta = world_db["ThingActions"][id] - ta_string = ta_string + "TA_ID " + str(id) + "\n" + \ - "TA_EFFORT " + str(ta["TA_EFFORT"]) + "\n" + \ - "TA_NAME '" + ta["TA_NAME"] + "'\n" - tt_string = "" + """Save all commands needed to reconstruct current world state.""" + # TODO: Misses same optimizations as record() from the original record(). + + def quote(string): + string = string.replace("\u005C", '\u005C\u005C') + return '"' + string.replace('"', '\u005C"') + '"' + + def mapsetter(key): + def helper(id): + string = "" + if world_db["Things"][id][key]: + rmap = world_db["Things"][id][key] + length = world_db["MAP_LENGTH"] + for i in range(length): + line = rmap[i * length:(i * length) + length].decode() + string = string + key + " " + str(i) + quote(line) + "\n" + return string + return helper + + def memthing(id): + string = "" + for memthing in world_db["Things"][id]["T_MEMTHING"]: + string = string + "T_MEMTHING " + str(memthing[0]) + " " + \ + str(memthing[1]) + " " + str(memthing[2]) + "\n" + return string + + def helper(category, id_string, special_keys={}): + string = "" + for id in world_db[category]: + string = string + id_string + " " + str(id) + "\n" + for key in world_db[category][id]: + if not key in special_keys: + x = world_db[category][id][key] + argument = quote(x) if str == type(x) else str(x) + string = string + key + " " + argument + "\n" + elif special_keys[key]: + string = string + special_keys[key](id) + return string + + string = "" + for key in world_db: + if dict != type(world_db[key]) and key != "MAP": + string = string + key + " " + str(world_db[key]) + "\n" + string = string + helper("ThingActions", "TA_ID") + string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False}) for id in world_db["ThingTypes"]: - tt = world_db["ThingTypes"][id] - tt_string = tt_string + "TT_ID " + str(id) + "\n" + \ - "TT_CONSUMABLE " + \ - str(tt["TT_CONSUMABLE"]) + "\n" + \ - "TT_CORPSE_ID " + \ - str(tt["TT_CORPSE_ID"]) + "\n" + \ - "TT_PROLIFERATE " + \ - str(tt["TT_PROLIFERATE"]) + "\n" + \ - "TT_START_NUMBER " + \ - str(tt["TT_START_NUMBER"]) + "\n" + \ - "TT_NAME '" + tt["TT_NAME"] + "'\n" + \ - "TT_SYMBOL '" + tt["TT_SYMBOL"] + "'\n" - atomic_write(io_db["path_save"], - "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"]) + "\n" + - "MAP_LENGTH " + str(world_db["MAP_LENGTH"]) + "\n" + - "PLAYER_TYPE " + str(world_db["PLAYER_TYPE"]) + "\n" + - "TURN " + str(world_db["TURN"]) + "\n" + - "SEED_RANDOMNESS " + str(world_db["SEED_RANDOMNESS"]) + "\n" + - "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n" + - ta_string + tt_string) - # TODO: If all this ever does is just writing down what's in world_db, some - # loop over its entries should be all that's needed. + string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \ + str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n" + string = string + helper("Things", "T_ID", + {"T_CARRIES": False, "carried": False, + "T_MEMMAP": mapsetter("T_MEMMAP"), + "T_MEMTHING": memthing, + "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")}) + for id in world_db["Things"]: + if [] != world_db["Things"][id]["T_CARRIES"]: + 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"]) + atomic_write(io_db["path_save"], string) def obey_lines_in_file(path, name, do_record=False): @@ -216,12 +250,41 @@ def read_command(): return command +def try_worldstate_update(): + """Write worldstate file if io_db["worldstate_updateable"] is set.""" + if io_db["worldstate_updateable"]: + inventory = "" + if [] == world_db["Things"][0]["T_CARRIES"]: + inventory = "(none)\n" + else: + for id in world_db["Things"][0]["T_CARRIES"]: + type_id = world_db["Things"][id]["T_TYPE"] + name = world_db["ThingTypes"][type_id]["TT_NAME"] + inventory = inventory + name + "\n" + string = str(world_db["TURN"]) + "\n" + \ + str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \ + str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \ + inventory + "%\n" + \ + str(world_db["Things"][0]["T_POSY"]) + "\n" + \ + str(world_db["Things"][0]["T_POSX"]) + "\n" + \ + str(world_db["MAP_LENGTH"]) + "\n" + length = world_db["MAP_LENGTH"] + for i in range(length): + line = world_db["MAP"][i * length:(i * length) + length].decode() + string = string + line + "\n" + # TODO: no proper user-subjective map + atomic_write(io_db["path_worldstate"], string) + strong_write(io_db["file_out"], "WORLD_UPDATED\n") + io_db["worldstate_updateable"] = False + + def replay_game(): """Replay game from record file. Use opts.replay as breakpoint turn to which to replay automatically before switching to manual input by non-meta commands in server input file triggering further reads of record file. Ensure opts.replay is at least 1. + Run try_worldstate_update() before each interactive obey()/read_command(). """ if opts.replay < 1: opts.replay = 1 @@ -240,6 +303,7 @@ def replay_game(): + str(io_db["file_record"].line_n)) io_db["file_record"].line_n = io_db["file_record"].line_n + 1 while True: + try_worldstate_update() obey(read_command(), "in file", replay=True) @@ -248,7 +312,8 @@ def play_game(): If no save file is found, a new world is generated from the commands in the world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this - command and all that follow via the server input file. + command and all that follow via the server input file. Run + try_worldstate_update() before each interactive obey()/read_command(). """ if os.access(io_db["path_save"], os.F_OK): obey_lines_in_file(io_db["path_save"], "save") @@ -260,12 +325,13 @@ def play_game(): do_record=True) obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True) while True: + try_worldstate_update() obey(read_command(), "in file", do_record=True) def remake_map(): - # DUMMY. - print("I'd (re-)make the map now, if only I knew how.") + # DUMMY map creator. + world_db["MAP"] = bytearray(b'.' * (world_db["MAP_LENGTH"] ** 2)) def set_world_inactive(): @@ -277,7 +343,7 @@ def set_world_inactive(): def integer_test(val_string, min, max): - """Return val_string if possible integer >= min and <= max, else False.""" + """Return val_string if possible integer >= min and <= max, else None.""" try: val = int(val_string) if val < min or val > max: @@ -286,22 +352,92 @@ def integer_test(val_string, min, max): except ValueError: print("Ignoring: Please use integer >= " + str(min) + " and <= " + str(max) + ".") - return False + return None + + +def setter(category, key, min, max): + """Build setter for world_db([category + "s"][id])[key] to >=min/<=max.""" + if category is None: + def f(val_string): + val = integer_test(val_string, min, max) + if None != val: + world_db[key] = val + else: + if category == "Thing": + id_store = command_tid + decorator = test_Thing_id + elif category == "ThingType": + id_store = command_ttid + decorator = test_ThingType_id + elif category == "ThingAction": + id_store = command_taid + decorator = test_ThingAction_id + + @decorator + def f(val_string): + val = integer_test(val_string, min, max) + if None != val: + world_db[category + "s"][id_store.id][key] = val + return f -def worlddb_value_setter(key, min, max): - """Generate: Set world_db[key] to int(val_string) if >= min and <= max.""" - def func(val_string): - val = integer_test(val_string, min, max) - if val: - world_db[key] = val - return func +def new_Thing(type): + """Return prototype for Thing of T_TYPE of type.""" + return { + "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"], + "T_ARGUMENT": 0, + "T_PROGRESS": 0, + "T_SATIATION": 0, + "T_COMMAND": 0, + "T_TYPE": type, + "T_POSY": 0, + "T_POSX": 0, + "T_CARRIES": [], + "carried": False, + "T_MEMTHING": [], + "T_MEMMAP": False, + "T_MEMDEPTHMAP": False + } + + +def id_setter(id, category, id_store=False, start_at_1=False): + """Set ID of object of category to manipulate ID unused? Create new one. + + The ID is stored as id_store.id (if id_store is set). If the integer of the + input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <= + 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID + >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no + new object is created, otherwise the new object's ID. + """ + min = 0 if start_at_1 else -32768 + max = 255 if start_at_1 else 32767 + if str == type(id): + id = integer_test(id, min, max) + if None != id: + if id in world_db[category]: + if id_store: + id_store.id = id + return None + else: + if (start_at_1 and 0 == id) \ + or ((not start_at_1) and (id < 0 or id > 255)): + id = -1 + while 1: + id = id + 1 + if id not in world_db[category]: + break + if id > 255: + print("Ignoring: " + "No unused ID available to add to ID list.") + return None + if id_store: + id_store.id = id + return id def command_ping(): """Send PONG line to server output file.""" - io_db["file_out"].write("PONG\n") - io_db["file_out"].flush() + strong_write(io_db["file_out"], "PONG\n") def command_quit(): @@ -309,78 +445,103 @@ def command_quit(): raise SystemExit("received QUIT command") +def command_thingshere(y, x): + # DUMMY + print("Ignoring not-yet implemented THINGS_HERE command.") + + def command_seedmap(seed_string): """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map.""" - worlddb_value_setter("SEED_MAP", 0, 4294967295)(seed_string) + setter(None, "SEED_MAP", 0, 4294967295)(seed_string) remake_map() def command_makeworld(seed_string): - # DUMMY. - worlddb_value_setter("SEED_MAP", 0, 4294967295)(seed_string) - worlddb_value_setter("SEED_RANDOMNESS", 0, 4294967295)(seed_string) - # TODO: Test for existence of player thing and 'wait' thing action? + """(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() + 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 FOV/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) + player_will_be_generated = False + playertype = world_db["PLAYER_TYPE"] + for ThingType in world_db["ThingTypes"]: + if playertype == ThingType: + if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]: + player_will_be_generated = True + break + if not player_will_be_generated: + print("Ignoring beyond SEED_MAP: " + + "No player type with start number >0 defined.") + return + wait_action = False + for ThingAction in world_db["ThingActions"]: + if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]: + wait_action = True + if not wait_action: + print("Ignoring beyond SEED_MAP: " + + "No thing action with name 'wait' defined.") + return + world_db["Things"] = {} + remake_map() + world_db["WORLD_ACTIVE"] = 1 + 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. Init player's FOV / memory map. + for type in world_db["ThingTypes"]: + for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]): + id = id_setter(-1, "Things") + world_db["Things"][id] = new_Thing(playertype) + # TODO: Positioning. + strong_write(io_db["file_out"], "NEW_WORLD\n") def command_maplength(maplength_string): - # DUMMY. + """Redefine map length. Invalidate map, therefore lose all things on it.""" set_world_inactive() - # TODO: remove things, map - worlddb_value_setter("MAP_LENGTH", 1, 256)(maplength_string) + world_db["Things"] = {} + setter(None, "MAP_LENGTH", 1, 256)(maplength_string) def command_worldactive(worldactive_string): - # DUMMY. + """Toggle world_db["WORLD_ACTIVE"] if possible. + + An active world can always be set inactive. An inactive world can only be + set active with a "wait" ThingAction, and a player Thing (of ID 0). On + activation, rebuild all Things' FOVs and map memories. + """ + # In original version, map existence was also tested (unnecessarily?). val = integer_test(worldactive_string, 0, 1) if val: - if 0 != world_db["WORLD_ACTIVE"] and 0 == val: - set_world_inactive() + if 0 != world_db["WORLD_ACTIVE"]: + if 0 == val: + set_world_inactive() + else: + print("World already active.") elif 0 == world_db["WORLD_ACTIVE"]: wait_exists = False + for ThingAction in world_db["ThingActions"]: + if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]: + wait_exists = True + break player_exists = False - map_exists = False - # TODO: perform tests: - # Is there thing action of name 'wait'? - # Is there a player thing? - # Is there a map? - if wait_exists and player_exists and map_exists: - # TODO: rebuild al things' FOVs, map memories + for Thing in world_db["Things"]: + if 0 == Thing: + player_exists = True + break + if wait_exists and player_exists: + # TODO: rebuild all things' FOVs, map memories world_db["WORLD_ACTIVE"] = 1 -def command_ttid(id_string): - """Set ID of ThingType to manipulate. ID unused? Create new ThingType. - - The ID of the ThingType to manipulate is stored as command_ttid.id. If - the integer of the input value is valid (>= -32768 and <= 32767), but <0 or - >255, a new ID is calculated: the lowest unused ID >=0 and <= 255. - """ - id = integer_test(id_string, -32768, 32767) - if id: - if id in world_db["ThingTypes"]: - command_ttid.id = id - else: - if id < 0 or id > 255: - id = -1 - while 1: - id = id + 1 - if id not in world_db["ThingTypes"]: - break - if id > 255: - print("Ignoring: " - "No unused ID available to add to ID list.") - return - command_ttid.id = id - world_db["ThingTypes"][id] = { - "TT_NAME": "(none)", - "TT_CONSUMABLE": 0, - "TT_PROLIFERATE": 0, - "TT_START_NUMBER": 0, - "TT_SYMBOL": "?", - "TT_CORPSE_ID": id - } - - def test_for_id_maker(object, category): """Return decorator testing for object having "id" attribute.""" def decorator(f): @@ -394,28 +555,154 @@ def test_for_id_maker(object, category): return decorator -test_ThingType_id = test_for_id_maker(command_ttid, "ThingType") +def command_tid(id_string): + """Set ID of Thing to manipulate. ID unused? Create new one. + Default new Thing's type to the first available ThingType, others: zero. + """ + id = id_setter(id_string, "Things", command_tid) + if None != id: + if world_db["ThingTypes"] == {}: + print("Ignoring: No ThingType to settle new Thing in.") + return + type = list(world_db["ThingTypes"].keys())[0] + world_db["Things"][id] = new_Thing(type) -def ThingType_value_setter(key, min, max): - """Build: Set selected ThingType's [key] to int(val_string) >=min/<=max.""" - @test_ThingType_id - def f(val_string): - val = integer_test(val_string, min, max) - if val: - world_db["ThingTypes"][command_ttid.id][key] = val - return f + +test_Thing_id = test_for_id_maker(command_tid, "Thing") + + +@test_Thing_id +def command_tcommand(str_int): + """Set T_COMMAND of selected Thing.""" + val = integer_test(str_int, 0, 255) + if None != val: + if 0 == val or val in world_db["ThingActions"]: + world_db["Things"][command_tid.id]["T_COMMAND"] = val + else: + print("Ignoring: ThingAction ID belongs to no known ThingAction.") + + +@test_Thing_id +def command_ttype(str_int): + """Set T_TYPE of selected Thing.""" + val = integer_test(str_int, 0, 255) + if None != val: + if val in world_db["ThingTypes"]: + world_db["Things"][command_tid.id]["T_TYPE"] = val + else: + print("Ignoring: ThingType ID belongs to no known ThingType.") + + +@test_Thing_id +def command_tcarries(str_int): + """Append int(str_int) to T_CARRIES of selected Thing. + + The ID int(str_int) must not be of the selected Thing, and must belong to a + Thing with unset "carried" flag. Its "carried" flag will be set on owning. + """ + val = integer_test(str_int, 0, 255) + if None != val: + if val == command_tid.id: + print("Ignoring: Thing cannot carry itself.") + elif val in world_db["Things"] \ + and not world_db["Things"][val]["carried"]: + world_db["Things"][command_tid.id]["T_CARRIES"].append(val) + world_db["Things"][val]["carried"] = True + else: + print("Ignoring: Thing not available for carrying.") + # Note that the whole carrying structure is different from the C version: + # Carried-ness is marked by a "carried" flag, not by Things containing + # Things internally. + + +@test_Thing_id +def command_tmemthing(str_t, str_y, str_x): + """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING. + + The type must fit to an existing ThingType, and the position into the map. + """ + type = integer_test(str_t, 0, 255) + posy = integer_test(str_y, 0, 255) + posx = integer_test(str_x, 0, 255) + if None != type and None != posy and None != posx: + if type not in world_db["ThingTypes"] \ + or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]: + print("Ignoring: Illegal value for thing type or position.") + else: + memthing = (type, posy, posx) + world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing) + + +def setter_map(maptype): + """Set selected Thing's map of maptype's int(str_int)-th line to mapline. + + If Thing has no map of maptype yet, initialize it with ' ' bytes first. + """ + @test_Thing_id + def helper(str_int, mapline): + val = integer_test(str_int, 0, 255) + if None != val: + if val >= world_db["MAP_LENGTH"]: + print("Illegal value for map line number.") + elif len(mapline) != world_db["MAP_LENGTH"]: + print("Map line length is unequal map width.") + else: + length = world_db["MAP_LENGTH"] + rmap = None + if not world_db["Things"][command_tid.id][maptype]: + rmap = bytearray(b' ' * (length ** 2)) + else: + rmap = world_db["Things"][command_tid.id][maptype] + rmap[val * length:(val * length) + length] = mapline.encode() + world_db["Things"][command_tid.id][maptype] = rmap + return helper + + +def setter_tpos(axis): + """Generate setter for T_POSX or T_POSY of selected Thing.""" + @test_Thing_id + def helper(str_int): + val = integer_test(str_int, 0, 255) + if None != val: + if val < world_db["MAP_LENGTH"]: + world_db["Things"][command_tid.id]["T_POS" + axis] = val + # TODO: Delete Thing's FOV, and rebuild it if world is active. + else: + print("Ignoring: Position is outside of map.") + return helper + + +def command_ttid(id_string): + """Set ID of ThingType to manipulate. ID unused? Create new one. + + Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0. + """ + id = id_setter(id_string, "ThingTypes", command_ttid) + if None != id: + world_db["ThingTypes"][id] = { + "TT_NAME": "(none)", + "TT_CONSUMABLE": 0, + "TT_LIFEPOINTS": 0, + "TT_PROLIFERATE": 0, + "TT_START_NUMBER": 0, + "TT_SYMBOL": "?", + "TT_CORPSE_ID": id + } + + +test_ThingType_id = test_for_id_maker(command_ttid, "ThingType") @test_ThingType_id def command_ttname(name): - """Set to name TT_NAME of selected ThingType.""" + """Set TT_NAME of selected ThingType.""" world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name @test_ThingType_id def command_ttsymbol(char): - """Set to char TT_SYMBOL of selected ThingType. """ + """Set TT_SYMBOL of selected ThingType. """ if 1 == len(char): world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char else: @@ -424,57 +711,34 @@ def command_ttsymbol(char): @test_ThingType_id def command_ttcorpseid(str_int): - """Set to int(str_int) TT_CORPSE_ID of selected ThingType.""" + """Set TT_CORPSE_ID of selected ThingType.""" val = integer_test(str_int, 0, 255) - if val: + if None != val: if val in world_db["ThingTypes"]: world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val else: - print("Corpse ID belongs to no known object type.") + print("Ignoring: Corpse ID belongs to no known ThignType.") def command_taid(id_string): - """Set ID of ThingAction to manipulate. ID unused? Create new ThingAction. + """Set ID of ThingAction to manipulate. ID unused? Create new one. - The ID of the ThingAction to manipulate is stored as command_taid.id. If - the integer of the input value is valid (>= 0 and <= 255), but 0, a new ID - is calculated: The lowest unused ID >0 and <= 255. + Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait". """ - id = integer_test(id_string, 0, 255) - if id: - if id in world_db["ThingActions"]: - command_taid.id = id - else: - if 0 == id: - while 1: - id = id + 1 - if id not in world_db["ThingActions"]: - break - if id > 255: - print("Ignoring: " - "No unused ID available to add to ID list.") - return - command_taid.id = id - world_db["ThingActions"][id] = { - "TA_EFFORT": 1, - "TA_NAME": "wait" - } + id = id_setter(id_string, "ThingActions", command_taid, True) + if None != id: + world_db["ThingActions"][id] = { + "TA_EFFORT": 1, + "TA_NAME": "wait" + } test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction") -@test_ThingAction_id -def command_taeffort(str_int): - """Set to int(str_int) TA_EFFORT of selected ThingAction.""" - val = integer_test(str_int, 0, 255) - if val: - world_db["ThingActions"][command_taid.id]["TA_EFFORT"] = val - - @test_ThingAction_id def command_taname(name): - """Set to name TA_NAME of selected ThingAction. + """Set TA_NAME of selected ThingAction. The name must match a valid thing action function. If after the name setting no ThingAction with name "wait" remains, call set_world_inactive(). @@ -505,33 +769,48 @@ to be called on it. commands_db = { "QUIT": (0, True, command_quit), "PING": (0, True, command_ping), + "THINGS_HERE": (2, True, command_thingshere), "MAKE_WORLD": (1, False, command_makeworld), "SEED_MAP": (1, False, command_seedmap), - "SEED_RANDOMNESS": (1, False, worlddb_value_setter("SEED_RANDOMNESS", - 0, 4294967295)), - "TURN": (1, False, worlddb_value_setter("TURN", 0, 65535)), - "PLAYER_TYPE": (1, False, worlddb_value_setter("PLAYER_TYPE", 0, 255)), + "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS", + 0, 4294967295)), + "TURN": (1, False, setter(None, "TURN", 0, 65535)), + "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)), "MAP_LENGTH": (1, False, command_maplength), "WORLD_ACTIVE": (1, False, command_worldactive), "TA_ID": (1, False, command_taid), - "TA_EFFORT": (1, False, command_taeffort), + "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)), "TA_NAME": (1, False, command_taname), "TT_ID": (1, False, command_ttid), "TT_NAME": (1, False, command_ttname), "TT_SYMBOL": (1, False, command_ttsymbol), "TT_CORPSE_ID": (1, False, command_ttcorpseid), - "TT_CONSUMABLE": (1, False, ThingType_value_setter("TT_CONSUMABLE", - 0, 65535)), - "TT_START_NUMBER": (1, False, ThingType_value_setter("TT_START_NUMBER", - 0, 255)), - "TT_PROLIFERATE": (1, False, ThingType_value_setter("TT_PROLIFERATE", - 0, 255)) + "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE", + 0, 65535)), + "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER", + 0, 255)), + "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE", + 0, 255)), + "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)), + "T_ID": (1, False, command_tid), + "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)), + "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)), + "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)), + "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)), + "T_COMMAND": (1, False, command_tcommand), + "T_TYPE": (1, False, command_ttype), + "T_CARRIES": (1, False, command_tcarries), + "T_MEMMAP": (2, False, setter_map("T_MEMMAP")), + "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")), + "T_MEMTHING": (3, False, command_tmemthing), + "T_POSY": (1, False, setter_tpos("Y")), + "T_POSX": (1, False, setter_tpos("X")), } """World state database. With sane default values.""" world_db = { - "TURN": 1, + "TURN": 0, "SEED_MAP": 0, "SEED_RANDOMNESS": 0, "PLAYER_TYPE": 0, @@ -553,7 +832,8 @@ io_db = { "path_out": "server/out", "path_worldstate": "server/worldstate", "tmp_suffix": "_tmp", - "kicked_by_rival": False + "kicked_by_rival": False, + "worldstate_updateable": False }