X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=plomrogue-server.py;h=99f1c6017d38aaa2fe6e9c77c1c3e51ca3f24050;hb=307b04dbc3e4065a61c7d804953da9dc1c1cba0b;hp=5a45c1b18b41fbd2b56956e3fb069c6d2c5d003e;hpb=3598b2537f135ff7b7635e22a823661c6bdb9ff5;p=plomrogue

diff --git a/plomrogue-server.py b/plomrogue-server.py
index 5a45c1b..99f1c60 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.")
 
 
@@ -117,13 +117,65 @@ 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().
-    atomic_write(io_db["path_save"],
-                 "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")
+    """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(world_db["MAP_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]):
+            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"]:
+        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"
+    atomic_write(io_db["path_save"], string)
 
 
 def obey_lines_in_file(path, name, do_record=False):
@@ -243,18 +295,51 @@ def remake_map():
     print("I'd (re-)make the map now, if only I knew how.")
 
 
-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
-            world_db[key] = val
-        except ValueError:
-            print("Ignoring: Please use integer >= " + str(min) + " and <= " +
-                  "str(max)+ '.")
-    return func
+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 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 command_ping():
@@ -270,14 +355,304 @@ def command_quit():
 
 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):
-    # Mere dummy so far.
-    worlddb_value_setter("SEED_MAP", 0, 4294967295)(seed_string)
-    worlddb_value_setter("SEED_RANDOMNESS", 0, 4294967295)(seed_string)
+    # DUMMY.
+    setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
+    setter(None, "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 map
+    world_db["Things"] = {}
+    setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
+
+
+def command_worldactive(worldactive_string):
+    # DUMMY.
+    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 id_setter(id_string, category, id_store, 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 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
+    id = integer_test(id_string, min, max)
+    if None != id:
+        if id in world_db[category]:
+            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
+            id_store.id = id
+    return 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
+
+
+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
+        world_db["Things"][id] = {
+            "T_LIFEPOINTS": 0,
+            "T_ARGUMENT": 0,
+            "T_PROGRESS": 0,
+            "T_SATIATION": 0,
+            "T_COMMAND": 0,
+            "T_TYPE": list(world_db["ThingTypes"].keys())[0],
+            "T_POSY": 0,
+            "T_POSX": 0,
+            "T_CARRIES": [],
+            "carried": False,
+            "T_MEMTHING": [],
+            "T_MEMMAP": False,
+            "T_MEMDEPTHMAP": False
+        }
+
+
+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 TT_NAME of selected ThingType."""
+    world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
+
+
+@test_ThingType_id
+def command_ttsymbol(char):
+    """Set 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 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("Ignoring: Corpse ID belongs to no known ThignType.")
+
+
+def command_taid(id_string):
+    """Set ID of ThingAction to manipulate. ID unused? Create new one.
+
+    Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "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_taname(name):
+    """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().
+    """
+    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.
@@ -292,19 +667,53 @@ 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)),
-    "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, 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, 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,"""
+"""World state database. With sane default values."""
 world_db = {
-    "TURN": 0,
+    "TURN": 1,
     "SEED_MAP": 0,
     "SEED_RANDOMNESS": 0,
-    "PLAYER_TYPE": 0
+    "PLAYER_TYPE": 0,
+    "MAP_LENGTH": 64,
+    "WORLD_ACTIVE": 0,
+    "ThingActions": {},
+    "ThingTypes": {},
+    "Things": {}
 }