plomlompom.com Git - plomrogue/blob - plomrogue-server.py

   1 import argparse
   2 import errno
   3 import os
   4 import shlex
   5 import shutil
   6 import time
   7
   8
   9 def strong_write(file, string):
  10     """Apply write(string), flush(), and os.fsync() to file."""
  11     file.write(string)
  12     file.flush()
  13     os.fsync(file)
  14
  15
  16 def setup_server_io():
  17     """Fill IO files DB with proper file( path)s. Write process IO test string.
  18
  19     Ensure IO files directory at server/. Remove any old input file if found.
  20     Set up new input file for reading, and new output file for writing. Start
  21     output file with process hash line of format PID + " " + floated UNIX time
  22     (io_db["teststring"]). Raise SystemExit if file is found at path of either
  23     record or save file plus io_db["tmp_suffix"].
  24     """
  25     def detect_atomic_leftover(path, tmp_suffix):
  26         path_tmp = path + tmp_suffix
  27         msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
  28               "aborted previous attempt to write '" + path + "'. Aborting " \
  29              "until matter is resolved by removing it from its current path."
  30         if os.access(path_tmp, os.F_OK):
  31             raise SystemExit(msg)
  32     io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
  33     os.makedirs(io_db["path_server"], exist_ok=True)
  34     io_db["file_out"] = open(io_db["path_out"], "w")
  35     strong_write(io_db["file_out"], io_db["teststring"] + "\n")
  36     if os.access(io_db["path_in"], os.F_OK):
  37         os.remove(io_db["path_in"])
  38     io_db["file_in"] = open(io_db["path_in"], "w")
  39     io_db["file_in"].close()
  40     io_db["file_in"] = open(io_db["path_in"], "r")
  41     detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
  42     detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
  43
  44
  45 def cleanup_server_io():
  46     """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
  47     def helper(file_key, path_key):
  48         if file_key in io_db:
  49             io_db[file_key].close()
  50             if not io_db["kicked_by_rival"] \
  51                and os.access(io_db[path_key], os.F_OK):
  52                 os.remove(io_db[path_key])
  53     helper("file_out", "path_out")
  54     helper("file_in", "path_in")
  55     helper("file_worldstate", "path_worldstate")
  56     if "file_record" in io_db:
  57         io_db["file_record"].close()
  58
  59
  60 def obey(command, prefix, replay=False, do_record=False):
  61     """Call function from commands_db mapped to command's first token.
  62
  63     Tokenize command string with shlex.split(comments=True). If replay is set,
  64     a non-meta command from the commands_db merely triggers obey() on the next
  65     command from the records file. If not, non-meta commands set
  66     io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
  67     do_record is set, are recorded via record(), and save_world() is called.
  68     The prefix string is inserted into the server's input message between its
  69     beginning 'input ' & ':'. All activity is preceded by a server_test() call.
  70     """
  71     server_test()
  72     print("input " + prefix + ": " + command)
  73     try:
  74         tokens = shlex.split(command, comments=True)
  75     except ValueError as err:
  76         print("Can't tokenize command string: " + str(err) + ".")
  77         return
  78     if len(tokens) > 0 and tokens[0] in commands_db \
  79        and len(tokens) == commands_db[tokens[0]][0] + 1:
  80         if commands_db[tokens[0]][1]:
  81             commands_db[tokens[0]][2](*tokens[1:])
  82         elif replay:
  83             print("Due to replay mode, reading command as 'go on in record'.")
  84             line = io_db["file_record"].readline()
  85             if len(line) > 0:
  86                 obey(line.rstrip(), io_db["file_record"].prefix
  87                      + str(io_db["file_record"].line_n))
  88                 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
  89             else:
  90                 print("Reached end of record file.")
  91         else:
  92             commands_db[tokens[0]][2](*tokens[1:])
  93             if do_record:
  94                 record(command)
  95                 save_world()
  96             io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
  97     elif 0 != len(tokens):
  98         print("Invalid command/argument, or bad number of tokens.")
  99
 100
 101 def atomic_write(path, text, do_append=False):
 102     """Atomic write of text to file at path, appended if do_append is set."""
 103     path_tmp = path + io_db["tmp_suffix"]
 104     mode = "w"
 105     if do_append:
 106         mode = "a"
 107         if os.access(path, os.F_OK):
 108             shutil.copyfile(path, path_tmp)
 109     file = open(path_tmp, mode)
 110     strong_write(file, text)
 111     file.close()
 112     if os.access(path, os.F_OK):
 113         os.remove(path)
 114     os.rename(path_tmp, path)
 115
 116
 117 def record(command):
 118     """Append command string plus newline to record file. (Atomic.)"""
 119     # This misses some optimizations from the original record(), namely only
 120     # finishing the atomic write with expensive flush() and fsync() every 15
 121     # seconds unless explicitely forced. Implement as needed.
 122     atomic_write(io_db["path_record"], command + "\n", do_append=True)
 123
 124
 125 def save_world():
 126     """Save all commands needed to reconstruct current world state."""
 127     # TODO: Misses same optimizations as record() from the original record().
 128
 129     def quote(string):
 130         string = string.replace("\u005C", '\u005C\u005C')
 131         return '"' + string.replace('"', '\u005C"') + '"'
 132
 133     def mapsetter(key):
 134         def helper(id):
 135             string = ""
 136             if world_db["Things"][id][key]:
 137                 map = world_db["Things"][id][key]
 138                 length = world_db["MAP_LENGTH"]
 139                 for i in range(length):
 140                     line = map[i * length:(i * length) + length].decode()
 141                     string = string + key + " " + str(i) + " " + quote(line) \
 142                              + "\n"
 143             return string
 144         return helper
 145
 146     def memthing(id):
 147         string = ""
 148         for memthing in world_db["Things"][id]["T_MEMTHING"]:
 149             string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
 150                      str(memthing[1]) + " " + str(memthing[2]) + "\n"
 151         return string
 152
 153     def helper(category, id_string, special_keys={}):
 154         string = ""
 155         for id in world_db[category]:
 156             string = string + id_string + " " + str(id) + "\n"
 157             for key in world_db[category][id]:
 158                 if not key in special_keys:
 159                     x = world_db[category][id][key]
 160                     argument = quote(x) if str == type(x) else str(x)
 161                     string = string + key + " " + argument + "\n"
 162                 elif special_keys[key]:
 163                     string = string + special_keys[key](id)
 164         return string
 165
 166     string = ""
 167     for key in world_db:
 168         if dict != type(world_db[key]) and key != "MAP":
 169             string = string + key + " " + str(world_db[key]) + "\n"
 170     string = string + helper("ThingActions", "TA_ID")
 171     string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
 172     for id in world_db["ThingTypes"]:
 173         string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
 174                  str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
 175     string = string + helper("Things", "T_ID",
 176                              {"T_CARRIES": False, "carried": False,
 177                               "T_MEMMAP": mapsetter("T_MEMMAP"),
 178                               "T_MEMTHING": memthing, "fovmap": False,
 179                               "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
 180     for id in world_db["Things"]:
 181         if [] != world_db["Things"][id]["T_CARRIES"]:
 182             string = string + "T_ID " + str(id) + "\n"
 183             for carried_id in world_db["Things"][id]["T_CARRIES"]:
 184                 string = string + "T_CARRIES " + str(carried_id) + "\n"
 185     string = string + "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
 186     atomic_write(io_db["path_save"], string)
 187
 188
 189 def obey_lines_in_file(path, name, do_record=False):
 190     """Call obey() on each line of path's file, use name in input prefix."""
 191     file = open(path, "r")
 192     line_n = 1
 193     for line in file.readlines():
 194         obey(line.rstrip(), name + "file line " + str(line_n),
 195              do_record=do_record)
 196         line_n = line_n + 1
 197     file.close()
 198
 199
 200 def parse_command_line_arguments():
 201     """Return settings values read from command line arguments."""
 202     parser = argparse.ArgumentParser()
 203     parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
 204                         action='store')
 205     opts, unknown = parser.parse_known_args()
 206     return opts
 207
 208
 209 def server_test():
 210     """Ensure valid server out file belonging to current process.
 211
 212     This is done by comparing io_db["teststring"] to what's found at the start
 213     of the current file at io_db["path_out"]. On failure, set
 214     io_db["kicked_by_rival"] and raise SystemExit.
 215     """
 216     if not os.access(io_db["path_out"], os.F_OK):
 217         raise SystemExit("Server output file has disappeared.")
 218     file = open(io_db["path_out"], "r")
 219     test = file.readline().rstrip("\n")
 220     file.close()
 221     if test != io_db["teststring"]:
 222         io_db["kicked_by_rival"] = True
 223         msg = "Server test string in server output file does not match. This" \
 224               " indicates that the current server process has been " \
 225               "superseded by another one."
 226         raise SystemExit(msg)
 227
 228
 229 def read_command():
 230     """Return next newline-delimited command from server in file.
 231
 232     Keep building return string until a newline is encountered. Pause between
 233     unsuccessful reads, and after too much waiting, run server_test().
 234     """
 235     wait_on_fail = 1
 236     max_wait = 5
 237     now = time.time()
 238     command = ""
 239     while True:
 240         add = io_db["file_in"].readline()
 241         if len(add) > 0:
 242             command = command + add
 243             if len(command) > 0 and "\n" == command[-1]:
 244                 command = command[:-1]
 245                 break
 246         else:
 247             time.sleep(wait_on_fail)
 248             if now + max_wait < time.time():
 249                 server_test()
 250                 now = time.time()
 251     return command
 252
 253
 254 def try_worldstate_update():
 255     """Write worldstate file if io_db["worldstate_updateable"] is set."""
 256     if io_db["worldstate_updateable"]:
 257
 258         def draw_visible_Things(map, run):
 259             for id in world_db["Things"]:
 260                 type = world_db["Things"][id]["T_TYPE"]
 261                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 262                 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
 263                 if (0 == run and not consumable and not alive) \
 264                    or (1 == run and consumable and not alive) \
 265                    or (2 == run and alive):
 266                     y = world_db["Things"][id]["T_POSY"]
 267                     x = world_db["Things"][id]["T_POSX"]
 268                     fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
 269                     if 'v' == chr(fovflag):
 270                         c = world_db["ThingTypes"][type]["TT_SYMBOL"]
 271                         map[(y * length) + x] = ord(c)
 272
 273         def write_map(string, map):
 274             for i in range(length):
 275                 line = map[i * length:(i * length) + length].decode()
 276                 string = string + line + "\n"
 277             return string
 278
 279         inventory = ""
 280         if [] == world_db["Things"][0]["T_CARRIES"]:
 281             inventory = "(none)\n"
 282         else:
 283             for id in world_db["Things"][0]["T_CARRIES"]:
 284                 type_id = world_db["Things"][id]["T_TYPE"]
 285                 name = world_db["ThingTypes"][type_id]["TT_NAME"]
 286                 inventory = inventory + name + "\n"
 287         string = str(world_db["TURN"]) + "\n" + \
 288                  str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
 289                  str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
 290                  inventory + "%\n" + \
 291                  str(world_db["Things"][0]["T_POSY"]) + "\n" + \
 292                  str(world_db["Things"][0]["T_POSX"]) + "\n" + \
 293                  str(world_db["MAP_LENGTH"]) + "\n"
 294         length = world_db["MAP_LENGTH"]
 295         fov = bytearray(b' ' * (length ** 2))
 296         for pos in range(length ** 2):
 297             if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
 298                 fov[pos] = world_db["MAP"][pos]
 299         for i in range(3):
 300             draw_visible_Things(fov, i)
 301         string = write_map(string, fov)
 302         mem = world_db["Things"][0]["T_MEMMAP"][:]
 303         for i in range(2):
 304             for memthing in world_db["Things"][0]["T_MEMTHING"]:
 305                 type = world_db["Things"][memthing[0]]["T_TYPE"]
 306                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 307                 if (i == 0 and not consumable) or (i == 1 and consumable):
 308                     c = world_db["ThingTypes"][type]["TT_SYMBOL"]
 309                     mem[(memthing[1] * length) + memthing[2]] = ord(c)
 310         string = write_map(string, mem)
 311         atomic_write(io_db["path_worldstate"], string)
 312         strong_write(io_db["file_out"], "WORLD_UPDATED\n")
 313         io_db["worldstate_updateable"] = False
 314
 315
 316 def replay_game():
 317     """Replay game from record file.
 318
 319     Use opts.replay as breakpoint turn to which to replay automatically before
 320     switching to manual input by non-meta commands in server input file
 321     triggering further reads of record file. Ensure opts.replay is at least 1.
 322     Run try_worldstate_update() before each interactive obey()/read_command().
 323     """
 324     if opts.replay < 1:
 325         opts.replay = 1
 326     print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
 327           " (if so late a turn is to be found).")
 328     if not os.access(io_db["path_record"], os.F_OK):
 329         raise SystemExit("No record file found to replay.")
 330     io_db["file_record"] = open(io_db["path_record"], "r")
 331     io_db["file_record"].prefix = "record file line "
 332     io_db["file_record"].line_n = 1
 333     while world_db["TURN"] < opts.replay:
 334         line = io_db["file_record"].readline()
 335         if "" == line:
 336             break
 337         obey(line.rstrip(), io_db["file_record"].prefix
 338              + str(io_db["file_record"].line_n))
 339         io_db["file_record"].line_n = io_db["file_record"].line_n + 1
 340     while True:
 341         try_worldstate_update()
 342         obey(read_command(), "in file", replay=True)
 343
 344
 345 def play_game():
 346     """Play game by server input file commands. Before, load save file found.
 347
 348     If no save file is found, a new world is generated from the commands in the
 349     world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
 350     command and all that follow via the server input file. Run
 351     try_worldstate_update() before each interactive obey()/read_command().
 352     """
 353     if os.access(io_db["path_save"], os.F_OK):
 354         obey_lines_in_file(io_db["path_save"], "save")
 355     else:
 356         if not os.access(io_db["path_worldconf"], os.F_OK):
 357             msg = "No world config file from which to start a new world."
 358             raise SystemExit(msg)
 359         obey_lines_in_file(io_db["path_worldconf"], "world config ",
 360                            do_record=True)
 361         obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
 362     while True:
 363         try_worldstate_update()
 364         obey(read_command(), "in file", do_record=True)
 365
 366
 367 def remake_map():
 368     # DUMMY map creator.
 369     world_db["MAP"] = bytearray(b'.' * (world_db["MAP_LENGTH"] ** 2))
 370
 371
 372 def update_map_memory(t):
 373     """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
 374     if not t["T_MEMMAP"]:
 375         t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 376     if not t["T_MEMDEPTHMAP"]:
 377         t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 378     for pos in range(world_db["MAP_LENGTH"] ** 2):
 379         if "v" == chr(t["fovmap"][pos]):
 380             t["T_MEMDEPTHMAP"][pos] = ord("0")
 381             if " " == chr(t["T_MEMMAP"][pos]):
 382                 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
 383             continue
 384         # TODO: Aging of MEMDEPTHMAP.
 385     for memthing in t["T_MEMTHING"]:
 386         y = world_db["Things"][memthing[0]]["T_POSY"]
 387         x = world_db["Things"][memthing[1]]["T_POSY"]
 388         if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
 389             t["T_MEMTHING"].remove(memthing)
 390     for id in world_db["Things"]:
 391         type = world_db["Things"][id]["T_TYPE"]
 392         if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
 393             y = world_db["Things"][id]["T_POSY"]
 394             x = world_db["Things"][id]["T_POSY"]
 395             if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
 396                 t["T_MEMTHING"].append((type, y, x))
 397
 398
 399 def set_world_inactive():
 400     """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
 401     server_test()
 402     if os.access(io_db["path_worldstate"], os.F_OK):
 403         os.remove(io_db["path_worldstate"])
 404     world_db["WORLD_ACTIVE"] = 0
 405
 406
 407 def integer_test(val_string, min, max):
 408     """Return val_string if possible integer >= min and <= max, else None."""
 409     try:
 410         val = int(val_string)
 411         if val < min or val > max:
 412             raise ValueError
 413         return val
 414     except ValueError:
 415         print("Ignoring: Please use integer >= " + str(min) + " and <= " +
 416               str(max) + ".")
 417         return None
 418
 419
 420 def setter(category, key, min, max):
 421     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
 422     if category is None:
 423         def f(val_string):
 424             val = integer_test(val_string, min, max)
 425             if None != val:
 426                 world_db[key] = val
 427     else:
 428         if category == "Thing":
 429             id_store = command_tid
 430             decorator = test_Thing_id
 431         elif category == "ThingType":
 432             id_store = command_ttid
 433             decorator = test_ThingType_id
 434         elif category == "ThingAction":
 435             id_store = command_taid
 436             decorator = test_ThingAction_id
 437
 438         @decorator
 439         def f(val_string):
 440             val = integer_test(val_string, min, max)
 441             if None != val:
 442                 world_db[category + "s"][id_store.id][key] = val
 443     return f
 444
 445
 446 def build_fov_map(t):
 447     """Build Thing's FOV map."""
 448     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
 449     # DUMMY so far. Just builds an all-visible map.
 450
 451
 452 def actor_wait(Thing):
 453     """Do nothing (but loudly, if by player)."""
 454     if Thing == world_db["Things"][0]:
 455         strong_write(io_db["file_out"], "LOG You wait.\n")
 456
 457
 458 def actor_move(Thing):
 459     pass
 460
 461
 462 def actor_pick_up(Thing):
 463     """Pick up (topmost?) thing from ground into inventory."""
 464     # Topmostness is actually not defined so far.
 465     ids = [id for id in world_db["Things"] if world_db["Things"][id] != Thing
 466            if not world_db["Things"][id]["carried"]
 467            if world_db["Things"][id]["T_POSY"] == Thing["T_POSY"]
 468            if world_db["Things"][id]["T_POSX"] == Thing["T_POSX"]]
 469     if ids:
 470         world_db["Things"][ids[0]]["carried"] = True
 471         Thing["T_CARRIES"].append(ids[0])
 472         strong_write(io_db["file_out"], "LOG You pick up an object.\n")
 473     else:
 474         err = "You try to pick up an object, but there is none."
 475         strong_write(io_db["file_out"], "LOG " + err + "\n")
 476
 477
 478 def actor_drop(Thing):
 479     pass
 480
 481
 482 def actor_use(Thing):
 483     pass
 484
 485
 486 def turn_over():
 487     """Run game world and its inhabitants until new player input expected."""
 488     id = 0
 489     whilebreaker = False
 490     while world_db["Things"][0]["T_LIFEPOINTS"]:
 491         for id in [id for id in world_db["Things"]
 492                    if world_db["Things"][id]["T_LIFEPOINTS"]]:
 493             Thing = world_db["Things"][id]
 494             if Thing["T_LIFEPOINTS"]:
 495                 if not Thing["T_COMMAND"]:
 496                     update_map_memory(Thing)
 497                     if 0 == id:
 498                         whilebreaker = True
 499                         break
 500                     # DUMMY: ai(thing)
 501                     Thing["T_COMMAND"] = 1
 502                 # DUMMY: try_healing
 503                 Thing["T_PROGRESS"] += 1
 504                 taid = [a for a in world_db["ThingActions"]
 505                           if a == Thing["T_COMMAND"]][0]
 506                 ThingAction = world_db["ThingActions"][taid]
 507                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
 508                     eval("actor_" + ThingAction["TA_NAME"])(Thing)
 509                     Thing["T_COMMAND"] = 0
 510                     Thing["T_PROGRESS"] = 0
 511                 # DUMMY: hunger
 512             # DUMMY: thingproliferation
 513         if whilebreaker:
 514             break
 515         world_db["TURN"] += 1
 516
 517
 518 def new_Thing(type):
 519     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
 520     thing = {
 521         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
 522         "T_ARGUMENT": 0,
 523         "T_PROGRESS": 0,
 524         "T_SATIATION": 0,
 525         "T_COMMAND": 0,
 526         "T_TYPE": type,
 527         "T_POSY": 0,
 528         "T_POSX": 0,
 529         "T_CARRIES": [],
 530         "carried": False,
 531         "T_MEMTHING": [],
 532         "T_MEMMAP": False,
 533         "T_MEMDEPTHMAP": False,
 534         "fovmap": False
 535     }
 536     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
 537         build_fov_map(thing)
 538     return thing
 539
 540
 541 def id_setter(id, category, id_store=False, start_at_1=False):
 542     """Set ID of object of category to manipulate ID unused? Create new one.
 543
 544     The ID is stored as id_store.id (if id_store is set). If the integer of the
 545     input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
 546     32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
 547     >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
 548     new object is created, otherwise the new object's ID.
 549     """
 550     min = 0 if start_at_1 else -32768
 551     max = 255 if start_at_1 else 32767
 552     if str == type(id):
 553         id = integer_test(id, min, max)
 554     if None != id:
 555         if id in world_db[category]:
 556             if id_store:
 557                 id_store.id = id
 558             return None
 559         else:
 560             if (start_at_1 and 0 == id) \
 561                or ((not start_at_1) and (id < 0 or id > 255)):
 562                 id = -1
 563                 while 1:
 564                     id = id + 1
 565                     if id not in world_db[category]:
 566                         break
 567                 if id > 255:
 568                     print("Ignoring: "
 569                           "No unused ID available to add to ID list.")
 570                     return None
 571             if id_store:
 572                 id_store.id = id
 573     return id
 574
 575
 576 def command_ping():
 577     """Send PONG line to server output file."""
 578     strong_write(io_db["file_out"], "PONG\n")
 579
 580
 581 def command_quit():
 582     """Abort server process."""
 583     raise SystemExit("received QUIT command")
 584
 585
 586 def command_thingshere(str_y, str_x):
 587     """Write to out file list of Things known to player at coordinate y, x."""
 588     def write_thing_if_here():
 589         if y == world_db["Things"][id]["T_POSY"] \
 590            and x == world_db["Things"][id]["T_POSX"] \
 591            and not world_db["Things"][id]["carried"]:
 592             type = world_db["Things"][id]["T_TYPE"]
 593             name = world_db["ThingTypes"][type]["TT_NAME"]
 594             strong_write(io_db["file_out"], name + "\n")
 595     if world_db["WORLD_ACTIVE"]:
 596         y = integer_test(str_y, 0, 255)
 597         x = integer_test(str_x, 0, 255)
 598         length = world_db["MAP_LENGTH"]
 599         if None != y and None != x and y < length and x < length:
 600             pos = (y * world_db["MAP_LENGTH"]) + x
 601             strong_write(io_db["file_out"], "THINGS_HERE START\n")
 602             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
 603                 for id in world_db["Things"]:
 604                     write_thing_if_here()
 605             else:
 606                 for id in world_db["Things"]["T_MEMTHING"]:
 607                     write_thing_if_here()
 608             strong_write(io_db["file_out"], "THINGS_HERE END\n")
 609         else:
 610             print("Ignoring: Invalid map coordinates.")
 611     else:
 612         print("Ignoring: Command only works on existing worlds.")
 613
 614
 615 def play_commander(action, args=False):
 616     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
 617
 618     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
 619     """
 620
 621     def set_command():
 622         id = [x for x in world_db["ThingActions"]
 623                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
 624         world_db["Things"][0]["T_COMMAND"] = id
 625         turn_over()
 626         # TODO: call turn_over()
 627
 628     def set_command_and_argument_int(str_arg):
 629         val = integer_test(str_arg, 0, 255)
 630         if None != val:
 631             world_db["Things"][0]["T_ARGUMENT"] = val
 632             set_command()
 633         else:
 634             print("Ignoring: Argument must be integer >= 0 <=255.")
 635
 636     def set_command_and_argument_movestring(str_arg):
 637         dirs = {"east": "d", "south-east": "c", "south-west": "x",
 638                 "west": "s", "north-west": "w", "north-east": "e"}
 639         if str_arg in dirs:
 640             world_db["Things"][0]["T_ARGUMENT"] = dirs[str_arg]
 641             set_command()
 642         else:
 643             print("Ignoring: Argument must be valid direction string.")
 644
 645     if action == "move":
 646         return set_command_and_argument_movestring
 647     elif args:
 648         return set_command_and_argument_int
 649     else:
 650         return set_command
 651
 652
 653 def command_seedmap(seed_string):
 654     """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
 655     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
 656     remake_map()
 657
 658
 659 def command_makeworld(seed_string):
 660     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
 661
 662     Make seed world_db["SEED_RANDOMNESS"] and world_db["SEED_MAP"]. Do more
 663     only with a "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType
 664     of TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
 665     and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
 666     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
 667     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
 668     other. Init player's memory map. Write "NEW_WORLD" line to out file.
 669     """
 670     setter(None, "SEED_RANDOMNESS", 0, 4294967295)(seed_string)
 671     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
 672     player_will_be_generated = False
 673     playertype = world_db["PLAYER_TYPE"]
 674     for ThingType in world_db["ThingTypes"]:
 675         if playertype == ThingType:
 676             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
 677                 player_will_be_generated = True
 678             break
 679     if not player_will_be_generated:
 680         print("Ignoring beyond SEED_MAP: " +
 681               "No player type with start number >0 defined.")
 682         return
 683     wait_action = False
 684     for ThingAction in world_db["ThingActions"]:
 685         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
 686             wait_action = True
 687     if not wait_action:
 688         print("Ignoring beyond SEED_MAP: " +
 689               "No thing action with name 'wait' defined.")
 690         return
 691     world_db["Things"] = {}
 692     remake_map()
 693     world_db["WORLD_ACTIVE"] = 1
 694     world_db["TURN"] = 1
 695     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
 696         id = id_setter(-1, "Things")
 697         world_db["Things"][id] = new_Thing(playertype)
 698     # TODO: Positioning.
 699     update_map_memory(world_db["Things"][0])
 700     for type in world_db["ThingTypes"]:
 701         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
 702             if type != playertype:
 703                 id = id_setter(-1, "Things")
 704                 world_db["Things"][id] = new_Thing(type)
 705     # TODO: Positioning.
 706     strong_write(io_db["file_out"], "NEW_WORLD\n")
 707
 708
 709 def command_maplength(maplength_string):
 710     """Redefine map length. Invalidate map, therefore lose all things on it."""
 711     set_world_inactive()
 712     world_db["Things"] = {}
 713     setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
 714
 715
 716 def command_worldactive(worldactive_string):
 717     """Toggle world_db["WORLD_ACTIVE"] if possible.
 718
 719     An active world can always be set inactive. An inactive world can only be
 720     set active with a "wait" ThingAction, and a player Thing (of ID 0). On
 721     activation, rebuild all Things' FOVs, and the player's map memory.
 722     """
 723     # In original version, map existence was also tested (unnecessarily?).
 724     val = integer_test(worldactive_string, 0, 1)
 725     if val:
 726         if 0 != world_db["WORLD_ACTIVE"]:
 727             if 0 == val:
 728                 set_world_inactive()
 729             else:
 730                 print("World already active.")
 731         elif 0 == world_db["WORLD_ACTIVE"]:
 732             wait_exists = False
 733             for ThingAction in world_db["ThingActions"]:
 734                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
 735                     wait_exists = True
 736                     break
 737             player_exists = False
 738             for Thing in world_db["Things"]:
 739                 if 0 == Thing:
 740                     player_exists = True
 741                     break
 742             if wait_exists and player_exists:
 743                 for id in world_db["Things"]:
 744                     if world_db["Things"][id]["T_LIFEPOINTS"]:
 745                         build_fov_map(world_db["Things"][id])
 746                         if 0 == id:
 747                             update_map_memory(world_db["Things"][id])
 748                 world_db["WORLD_ACTIVE"] = 1
 749
 750
 751 def test_for_id_maker(object, category):
 752     """Return decorator testing for object having "id" attribute."""
 753     def decorator(f):
 754         def helper(*args):
 755             if hasattr(object, "id"):
 756                 f(*args)
 757             else:
 758                 print("Ignoring: No " + category +
 759                       " defined to manipulate yet.")
 760         return helper
 761     return decorator
 762
 763
 764 def command_tid(id_string):
 765     """Set ID of Thing to manipulate. ID unused? Create new one.
 766
 767     Default new Thing's type to the first available ThingType, others: zero.
 768     """
 769     id = id_setter(id_string, "Things", command_tid)
 770     if None != id:
 771         if world_db["ThingTypes"] == {}:
 772             print("Ignoring: No ThingType to settle new Thing in.")
 773             return
 774         type = list(world_db["ThingTypes"].keys())[0]
 775         world_db["Things"][id] = new_Thing(type)
 776
 777
 778 test_Thing_id = test_for_id_maker(command_tid, "Thing")
 779
 780
 781 @test_Thing_id
 782 def command_tcommand(str_int):
 783     """Set T_COMMAND of selected Thing."""
 784     val = integer_test(str_int, 0, 255)
 785     if None != val:
 786         if 0 == val or val in world_db["ThingActions"]:
 787             world_db["Things"][command_tid.id]["T_COMMAND"] = val
 788         else:
 789             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
 790
 791
 792 @test_Thing_id
 793 def command_ttype(str_int):
 794     """Set T_TYPE of selected Thing."""
 795     val = integer_test(str_int, 0, 255)
 796     if None != val:
 797         if val in world_db["ThingTypes"]:
 798             world_db["Things"][command_tid.id]["T_TYPE"] = val
 799         else:
 800             print("Ignoring: ThingType ID belongs to no known ThingType.")
 801
 802
 803 @test_Thing_id
 804 def command_tcarries(str_int):
 805     """Append int(str_int) to T_CARRIES of selected Thing.
 806
 807     The ID int(str_int) must not be of the selected Thing, and must belong to a
 808     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
 809     """
 810     val = integer_test(str_int, 0, 255)
 811     if None != val:
 812         if val == command_tid.id:
 813             print("Ignoring: Thing cannot carry itself.")
 814         elif val in world_db["Things"] \
 815              and not world_db["Things"][val]["carried"]:
 816             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
 817             world_db["Things"][val]["carried"] = True
 818         else:
 819             print("Ignoring: Thing not available for carrying.")
 820     # Note that the whole carrying structure is different from the C version:
 821     # Carried-ness is marked by a "carried" flag, not by Things containing
 822     # Things internally.
 823
 824
 825 @test_Thing_id
 826 def command_tmemthing(str_t, str_y, str_x):
 827     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
 828
 829     The type must fit to an existing ThingType, and the position into the map.
 830     """
 831     type = integer_test(str_t, 0, 255)
 832     posy = integer_test(str_y, 0, 255)
 833     posx = integer_test(str_x, 0, 255)
 834     if None != type and None != posy and None != posx:
 835         if type not in world_db["ThingTypes"] \
 836            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
 837             print("Ignoring: Illegal value for thing type or position.")
 838         else:
 839             memthing = (type, posy, posx)
 840             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
 841
 842
 843 def setter_map(maptype):
 844     """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
 845
 846     If Thing has no map of maptype yet, initialize it with ' ' bytes first.
 847     """
 848     @test_Thing_id
 849     def helper(str_int, mapline):
 850         val = integer_test(str_int, 0, 255)
 851         if None != val:
 852             if val >= world_db["MAP_LENGTH"]:
 853                 print("Illegal value for map line number.")
 854             elif len(mapline) != world_db["MAP_LENGTH"]:
 855                 print("Map line length is unequal map width.")
 856             else:
 857                 length = world_db["MAP_LENGTH"]
 858                 map = None
 859                 if not world_db["Things"][command_tid.id][maptype]:
 860                     map = bytearray(b' ' * (length ** 2))
 861                 else:
 862                     map = world_db["Things"][command_tid.id][maptype]
 863                 map[val * length:(val * length) + length] = mapline.encode()
 864                 world_db["Things"][command_tid.id][maptype] = map
 865     return helper
 866
 867
 868 def setter_tpos(axis):
 869     """Generate setter for T_POSX or  T_POSY of selected Thing.
 870
 871     If world is active, rebuilds animate things' fovmap, player's memory map.
 872     """
 873     @test_Thing_id
 874     def helper(str_int):
 875         val = integer_test(str_int, 0, 255)
 876         if None != val:
 877             if val < world_db["MAP_LENGTH"]:
 878                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
 879                 if world_db["WORLD_ACTIVE"] \
 880                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
 881                     build_fov_map(world_db["Things"][command_tid.id])
 882                     if 0 == command_tid.id:
 883                         update_map_memory(world_db["Things"][command_tid.id])
 884             else:
 885                 print("Ignoring: Position is outside of map.")
 886     return helper
 887
 888
 889 def command_ttid(id_string):
 890     """Set ID of ThingType to manipulate. ID unused? Create new one.
 891
 892     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
 893     """
 894     id = id_setter(id_string, "ThingTypes", command_ttid)
 895     if None != id:
 896         world_db["ThingTypes"][id] = {
 897             "TT_NAME": "(none)",
 898             "TT_CONSUMABLE": 0,
 899             "TT_LIFEPOINTS": 0,
 900             "TT_PROLIFERATE": 0,
 901             "TT_START_NUMBER": 0,
 902             "TT_SYMBOL": "?",
 903             "TT_CORPSE_ID": id
 904         }
 905
 906
 907 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
 908
 909
 910 @test_ThingType_id
 911 def command_ttname(name):
 912     """Set TT_NAME of selected ThingType."""
 913     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
 914
 915
 916 @test_ThingType_id
 917 def command_ttsymbol(char):
 918     """Set TT_SYMBOL of selected ThingType. """
 919     if 1 == len(char):
 920         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
 921     else:
 922         print("Ignoring: Argument must be single character.")
 923
 924
 925 @test_ThingType_id
 926 def command_ttcorpseid(str_int):
 927     """Set TT_CORPSE_ID of selected ThingType."""
 928     val = integer_test(str_int, 0, 255)
 929     if None != val:
 930         if val in world_db["ThingTypes"]:
 931             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
 932         else:
 933             print("Ignoring: Corpse ID belongs to no known ThignType.")
 934
 935
 936 def command_taid(id_string):
 937     """Set ID of ThingAction to manipulate. ID unused? Create new one.
 938
 939     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
 940     """
 941     id = id_setter(id_string, "ThingActions", command_taid, True)
 942     if None != id:
 943         world_db["ThingActions"][id] = {
 944             "TA_EFFORT": 1,
 945             "TA_NAME": "wait"
 946         }
 947
 948
 949 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
 950
 951
 952 @test_ThingAction_id
 953 def command_taname(name):
 954     """Set TA_NAME of selected ThingAction.
 955
 956     The name must match a valid thing action function. If after the name
 957     setting no ThingAction with name "wait" remains, call set_world_inactive().
 958     """
 959     if name == "wait" or name == "move" or name == "use" or name == "drop" \
 960        or name == "pick_up":
 961         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
 962         if 1 == world_db["WORLD_ACTIVE"]:
 963             wait_defined = False
 964             for id in world_db["ThingActions"]:
 965                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
 966                     wait_defined = True
 967                     break
 968             if not wait_defined:
 969                 set_world_inactive()
 970     else:
 971         print("Ignoring: Invalid action name.")
 972     # In contrast to the original,naming won't map a function to a ThingAction.
 973
 974
 975 """Commands database.
 976
 977 Map command start tokens to ([0]) number of expected command arguments, ([1])
 978 the command's meta-ness (i.e. is it to be written to the record file, is it to
 979 be ignored in replay mode if read from server input file), and ([2]) a function
 980 to be called on it.
 981 """
 982 commands_db = {
 983     "QUIT": (0, True, command_quit),
 984     "PING": (0, True, command_ping),
 985     "THINGS_HERE": (2, True, command_thingshere),
 986     "MAKE_WORLD": (1, False, command_makeworld),
 987     "SEED_MAP": (1, False, command_seedmap),
 988     "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS",
 989                                          0, 4294967295)),
 990     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
 991     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
 992     "MAP_LENGTH": (1, False, command_maplength),
 993     "WORLD_ACTIVE": (1, False, command_worldactive),
 994     "TA_ID": (1, False, command_taid),
 995     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
 996     "TA_NAME": (1, False, command_taname),
 997     "TT_ID": (1, False, command_ttid),
 998     "TT_NAME": (1, False, command_ttname),
 999     "TT_SYMBOL": (1, False, command_ttsymbol),
1000     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1001     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1002                                        0, 65535)),
1003     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1004                                          0, 255)),
1005     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1006                                         0, 255)),
1007     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1008     "T_ID": (1, False, command_tid),
1009     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1010     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1011     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1012     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1013     "T_COMMAND": (1, False, command_tcommand),
1014     "T_TYPE": (1, False, command_ttype),
1015     "T_CARRIES": (1, False, command_tcarries),
1016     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1017     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1018     "T_MEMTHING": (3, False, command_tmemthing),
1019     "T_POSY": (1, False, setter_tpos("Y")),
1020     "T_POSX": (1, False, setter_tpos("X")),
1021     "wait": (0, False, play_commander("wait")),
1022     "move": (1, False, play_commander("move")),
1023     "pick_up": (0, False, play_commander("pick_up")),
1024     "drop": (1, False, play_commander("drop", True)),
1025     "use": (1, False, play_commander("use", True)),
1026 }
1027
1028
1029 """World state database. With sane default values."""
1030 world_db = {
1031     "TURN": 0,
1032     "SEED_MAP": 0,
1033     "SEED_RANDOMNESS": 0,
1034     "PLAYER_TYPE": 0,
1035     "MAP_LENGTH": 64,
1036     "WORLD_ACTIVE": 0,
1037     "ThingActions": {},
1038     "ThingTypes": {},
1039     "Things": {}
1040 }
1041
1042
1043 """File IO database."""
1044 io_db = {
1045     "path_save": "save",
1046     "path_record": "record",
1047     "path_worldconf": "confserver/world",
1048     "path_server": "server/",
1049     "path_in": "server/in",
1050     "path_out": "server/out",
1051     "path_worldstate": "server/worldstate",
1052     "tmp_suffix": "_tmp",
1053     "kicked_by_rival": False,
1054     "worldstate_updateable": False
1055 }
1056
1057
1058 try:
1059     opts = parse_command_line_arguments()
1060     setup_server_io()
1061     if None != opts.replay:
1062         replay_game()
1063     else:
1064         play_game()
1065 except SystemExit as exit:
1066     print("ABORTING: " + exit.args[0])
1067 except:
1068     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1069     raise
1070 finally:
1071     cleanup_server_io()