X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue-server.py;h=eb1267157f2a6598c347e10ab7b895721c7090cc;hb=f64676dc1f4da35e687031c868ac551dafc0e190;hp=0802d1f4f8928f4d1805812aa16d838c2252cab1;hpb=b90d2d0d4a1357bfdaf3244886e66bd6ac400ed4;p=plomrogue diff --git a/plomrogue-server.py b/plomrogue-server.py index 0802d1f..eb12671 100755 --- a/plomrogue-server.py +++ b/plomrogue-server.py @@ -86,7 +86,7 @@ def obey(command, prefix, replay=False, do_record=False): if do_record: record(command) save_world() - else: + elif 0 != len(tokens): print("Invalid command/argument, or bad number of tokens.") @@ -119,13 +119,36 @@ 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 = "" + 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_LIFEPOINTS " + \ + str(tt["TT_LIFEPOINTS"]) + "\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") + "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. @@ -247,17 +270,33 @@ def remake_map(): print("I'd (re-)make the map now, if only I knew how.") +def set_world_inactive(): + """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file.""" + server_test() + if os.access(io_db["path_worldstate"], os.F_OK): + os.remove(io_db["path_worldstate"]) + world_db["WORLD_ACTIVE"] = 0 + + +def integer_test(val_string, min, max): + """Return val_string if possible integer >= min and <= max, else None.""" + try: + val = int(val_string) + if val < min or val > max: + raise ValueError + return val + except ValueError: + print("Ignoring: Please use integer >= " + str(min) + " and <= " + + str(max) + ".") + return None + + def worlddb_value_setter(key, min, max): """Generate: Set world_db[key] to int(val_string) if >= min and <= max.""" def func(val_string): - try: - val = int(val_string) - if val < min or val > max: - raise ValueError + val = integer_test(val_string, min, max) + if val: world_db[key] = val - except ValueError: - print("Ignoring: Please use integer >= " + str(min) + " and <= " + - str(max) + ".") return func @@ -282,35 +321,181 @@ 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? def command_maplength(maplength_string): # DUMMY. + set_world_inactive() + # TODO: remove things, map worlddb_value_setter("MAP_LENGTH", 1, 256)(maplength_string) def command_worldactive(worldactive_string): # DUMMY. - try: - val = int(worldactive_string) - if not (0 == val or 1 == val): - raise ValueError - except ValueError: - print("Ignoring: Please use integer 0 or 1.") - return - if 0 != world_db["WORLD_ACTIVE"] and 0 == val: - world_db["WORLD_ACTIVE"] = 0 - elif 0 == world_db["WORLD_ACTIVE"]: - wait_exists = False - 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 - world_db["WORLD_ACTIVE"] = 1 + val = integer_test(worldactive_string, 0, 1) + if val: + if 0 != world_db["WORLD_ACTIVE"] and 0 == val: + set_world_inactive() + elif 0 == world_db["WORLD_ACTIVE"]: + wait_exists = False + 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 + 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 None != 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_LIFEPOINTS": 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): + def helper(*args): + if hasattr(object, "id"): + f(*args) + else: + print("Ignoring: No " + category + + " defined to manipulate yet.") + return helper + return decorator + + +test_ThingType_id = test_for_id_maker(command_ttid, "ThingType") + + +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 None != val: + world_db["ThingTypes"][command_ttid.id][key] = val + return f + + +@test_ThingType_id +def command_ttname(name): + """Set to name 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. """ + if 1 == len(char): + world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char + else: + print("Ignoring: Argument must be single character.") + + +@test_ThingType_id +def command_ttcorpseid(str_int): + """Set to int(str_int) TT_CORPSE_ID of selected ThingType.""" + val = integer_test(str_int, 0, 255) + 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.") + + +def command_taid(id_string): + """Set ID of ThingAction to manipulate. ID unused? Create new ThingAction. + + 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. + """ + id = integer_test(id_string, 0, 255) + if None != 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" + } + + +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 None != 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. + + The name must match a valid thing action function. If after the name + setting no ThingAction with name "wait" remains, call set_world_inactive(). + """ + if name == "wait" or name == "move" or name == "use" or name == "drop" \ + or name == "pick_up": + world_db["ThingActions"][command_taid.id]["TA_NAME"] = name + if 1 == world_db["WORLD_ACTIVE"]: + wait_defined = False + for id in world_db["ThingActions"]: + if "wait" == world_db["ThingActions"][id]["TA_NAME"]: + wait_defined = True + break + if not wait_defined: + set_world_inactive() + else: + print("Ignoring: Invalid action name.") + # In contrast to the original,naming won't map a function to a ThingAction. """Commands database. @@ -325,12 +510,27 @@ commands_db = { "PING": (0, True, command_ping), "MAKE_WORLD": (1, False, command_makeworld), "SEED_MAP": (1, False, command_seedmap), - "SEED_RANDOMNESS": (1, False, worlddb_value_setter("SEED_RANDOMNESS", 0, - 4294967295)), + "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)), "MAP_LENGTH": (1, False, command_maplength), - "WORLD_ACTIVE": (1, False, command_worldactive) + "WORLD_ACTIVE": (1, False, command_worldactive), + "TA_ID": (1, False, command_taid), + "TA_EFFORT": (1, False, command_taeffort), + "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_LIFEPOINTS": (1, False, ThingType_value_setter("TT_LIFEPOINTS", + 0, 255)) } @@ -341,7 +541,10 @@ world_db = { "SEED_RANDOMNESS": 0, "PLAYER_TYPE": 0, "MAP_LENGTH": 64, - "WORLD_ACTIVE": 0 + "WORLD_ACTIVE": 0, + "ThingActions": {}, + "ThingTypes": {}, + "Things": {} }