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

   1 #!/usr/bin/python3
   2
   3 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
   4 # or any later version. For details on its copyright, license, and warranties,
   5 # see the file NOTICE in the root directory of the PlomRogue source package.
   6
   7
   8 import argparse
   9 import errno
  10 import os
  11 import shlex
  12 import shutil
  13 import time
  14 import ctypes
  15 import math  # #
  16
  17
  18 class RandomnessIO:
  19     """"Interface to libplomrogue's pseudo-randomness generator."""
  20
  21     def set_seed(self, seed):
  22         libpr.seed_rrand(1, seed)
  23
  24     def get_seed(self):
  25         return libpr.seed_rrand(0, 0)
  26
  27     def next(self):
  28         return libpr.rrand()
  29
  30     seed = property(get_seed, set_seed)
  31
  32
  33 def prep_library():
  34     """Prepare ctypes library at ./libplomrogue.so"""
  35     libpath = ("./libplomrogue.so")
  36     if not os.access(libpath, os.F_OK):
  37         raise SystemExit("No library " + libpath + ", run ./redo first?")
  38     libpr = ctypes.cdll.LoadLibrary(libpath)
  39     libpr.seed_rrand.restype = ctypes.c_uint32
  40     return libpr
  41
  42
  43 def c_pointer_to_bytearray(ba):
  44     """Return C char * pointer to ba."""
  45     type = ctypes.c_char * len(ba)
  46     return type.from_buffer(ba)
  47
  48
  49 def strong_write(file, string):
  50     """Apply write(string), then flush()."""
  51     file.write(string)
  52     file.flush()
  53
  54
  55 def setup_server_io():
  56     """Fill IO files DB with proper file( path)s. Write process IO test string.
  57
  58     Ensure IO files directory at server/. Remove any old input file if found.
  59     Set up new input file for reading, and new output file for writing. Start
  60     output file with process hash line of format PID + " " + floated UNIX time
  61     (io_db["teststring"]). Raise SystemExit if file is found at path of either
  62     record or save file plus io_db["tmp_suffix"].
  63     """
  64     def detect_atomic_leftover(path, tmp_suffix):
  65         path_tmp = path + tmp_suffix
  66         msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
  67               "aborted previous attempt to write '" + path + "'. Aborting " \
  68              "until matter is resolved by removing it from its current path."
  69         if os.access(path_tmp, os.F_OK):
  70             raise SystemExit(msg)
  71     io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
  72     io_db["save_wait"] = 0
  73     io_db["verbose"] = False
  74     io_db["record_chunk"] = ""
  75     os.makedirs(io_db["path_server"], exist_ok=True)
  76     io_db["file_out"] = open(io_db["path_out"], "w")
  77     strong_write(io_db["file_out"], io_db["teststring"] + "\n")
  78     if os.access(io_db["path_in"], os.F_OK):
  79         os.remove(io_db["path_in"])
  80     io_db["file_in"] = open(io_db["path_in"], "w")
  81     io_db["file_in"].close()
  82     io_db["file_in"] = open(io_db["path_in"], "r")
  83     detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
  84     detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
  85
  86
  87 def cleanup_server_io():
  88     """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
  89     def helper(file_key, path_key):
  90         if file_key in io_db:
  91             io_db[file_key].close()
  92         if not io_db["kicked_by_rival"] \
  93            and os.access(io_db[path_key], os.F_OK):
  94             os.remove(io_db[path_key])
  95     helper("file_in", "path_in")
  96     helper("file_out", "path_out")
  97     helper("file_worldstate", "path_worldstate")
  98     if "file_record" in io_db:
  99         io_db["file_record"].close()
 100
 101
 102 def obey(command, prefix, replay=False, do_record=False):
 103     """Call function from commands_db mapped to command's first token.
 104
 105     Tokenize command string with shlex.split(comments=True). If replay is set,
 106     a non-meta command from the commands_db merely triggers obey() on the next
 107     command from the records file. If not, non-meta commands set
 108     io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
 109     do_record is set, are recorded to io_db["record_chunk"], and save_world()
 110     is called (and io_db["record_chunk"] written) if 15 seconds have passed
 111     since the last time it was called. The prefix string is inserted into the
 112     server's input message between its beginning 'input ' and ':'. All activity
 113     is preceded by a server_test() call. Commands that start with a lowercase
 114     letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
 115     """
 116     server_test()
 117     if io_db["verbose"]:
 118         print("input " + prefix + ": " + command)
 119     try:
 120         tokens = shlex.split(command, comments=True)
 121     except ValueError as err:
 122         print("Can't tokenize command string: " + str(err) + ".")
 123         return
 124     if len(tokens) > 0 and tokens[0] in commands_db \
 125        and len(tokens) == commands_db[tokens[0]][0] + 1:
 126         if commands_db[tokens[0]][1]:
 127             commands_db[tokens[0]][2](*tokens[1:])
 128         elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
 129             print("Ignoring lowercase-starting commands when world inactive.")
 130         elif replay:
 131             print("Due to replay mode, reading command as 'go on in record'.")
 132             line = io_db["file_record"].readline()
 133             if len(line) > 0:
 134                 obey(line.rstrip(), io_db["file_record"].prefix
 135                      + str(io_db["file_record"].line_n))
 136                 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
 137             else:
 138                 print("Reached end of record file.")
 139         else:
 140             commands_db[tokens[0]][2](*tokens[1:])
 141             if do_record:
 142                 io_db["record_chunk"] += command + "\n"
 143                 if time.time() > io_db["save_wait"] + 15:
 144                     atomic_write(io_db["path_record"], io_db["record_chunk"],
 145                                  do_append=True)
 146                     if world_db["WORLD_ACTIVE"]:
 147                         save_world()
 148                     io_db["record_chunk"] = ""
 149                     io_db["save_wait"] = time.time()
 150             io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
 151     elif 0 != len(tokens):
 152         print("Invalid command/argument, or bad number of tokens.")
 153
 154
 155 def atomic_write(path, text, do_append=False, delete=True):
 156     """Atomic write of text to file at path, appended if do_append is set."""
 157     path_tmp = path + io_db["tmp_suffix"]
 158     mode = "w"
 159     if do_append:
 160         mode = "a"
 161         if os.access(path, os.F_OK):
 162             shutil.copyfile(path, path_tmp)
 163     file = open(path_tmp, mode)
 164     strong_write(file, text)
 165     file.close()
 166     if delete and os.access(path, os.F_OK):
 167         os.remove(path)
 168     os.rename(path_tmp, path)
 169
 170
 171 def save_world():
 172     """Save all commands needed to reconstruct current world state."""
 173
 174     def quote(string):
 175         string = string.replace("\u005C", '\u005C\u005C')
 176         return '"' + string.replace('"', '\u005C"') + '"'
 177
 178     def mapsetter(key):
 179         def helper(id=None):
 180             string = ""
 181             if key == "MAP" or world_db["Things"][id][key]:
 182                 map = world_db["MAP"] if key == "MAP" \
 183                                       else world_db["Things"][id][key]
 184                 length = world_db["MAP_LENGTH"]
 185                 for i in range(length):
 186                     line = map[i * length:(i * length) + length].decode()
 187                     string = string + key + " " + str(i) + " " + quote(line) \
 188                              + "\n"
 189             return string
 190         return helper
 191
 192     def memthing(id):
 193         string = ""
 194         for memthing in world_db["Things"][id]["T_MEMTHING"]:
 195             string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
 196                      str(memthing[1]) + " " + str(memthing[2]) + "\n"
 197         return string
 198
 199     def helper(category, id_string, special_keys={}):
 200         string = ""
 201         for id in world_db[category]:
 202             string = string + id_string + " " + str(id) + "\n"
 203             for key in world_db[category][id]:
 204                 if not key in special_keys:
 205                     x = world_db[category][id][key]
 206                     argument = quote(x) if str == type(x) else str(x)
 207                     string = string + key + " " + argument + "\n"
 208                 elif special_keys[key]:
 209                     string = string + special_keys[key](id)
 210         return string
 211
 212     string = ""
 213     for key in world_db:
 214         if (dict != type(world_db[key])
 215            and key != "ALTAR"   # #
 216            and key != "MAP" and key != "WORLD_ACTIVE"):
 217             string = string + key + " " + str(world_db[key]) + "\n"
 218     string = string + mapsetter("MAP")()
 219     string = (string + "ALTAR " + str(world_db["ALTAR"][0]) + " "  # #
 220                                 + str(world_db["ALTAR"][1]) + "\n")  # #
 221     string = string + helper("ThingActions", "TA_ID")
 222     string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
 223     for id in world_db["ThingTypes"]:
 224         string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
 225                  str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
 226     string = string + helper("Things", "T_ID",
 227                              {"T_CARRIES": False, "carried": False,
 228                               "T_MEMMAP": mapsetter("T_MEMMAP"),
 229                               "T_MEMTHING": memthing, "fovmap": False,
 230                               "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
 231     for id in world_db["Things"]:
 232         if [] != world_db["Things"][id]["T_CARRIES"]:
 233             string = string + "T_ID " + str(id) + "\n"
 234             for carried_id in world_db["Things"][id]["T_CARRIES"]:
 235                 string = string + "T_CARRIES " + str(carried_id) + "\n"
 236     string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
 237              "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
 238     atomic_write(io_db["path_save"], string)
 239
 240
 241 def obey_lines_in_file(path, name, do_record=False):
 242     """Call obey() on each line of path's file, use name in input prefix."""
 243     file = open(path, "r")
 244     line_n = 1
 245     for line in file.readlines():
 246         obey(line.rstrip(), name + "file line " + str(line_n),
 247              do_record=do_record)
 248         line_n = line_n + 1
 249     file.close()
 250
 251
 252 def parse_command_line_arguments():
 253     """Return settings values read from command line arguments."""
 254     parser = argparse.ArgumentParser()
 255     parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
 256                         action='store')
 257     parser.add_argument('-l', nargs="?", const="save", dest='savefile',
 258                         action="store")
 259     parser.add_argument('-v', dest='verbose', action='store_true')
 260     opts, unknown = parser.parse_known_args()
 261     return opts
 262
 263
 264 def server_test():
 265     """Ensure valid server out file belonging to current process.
 266
 267     This is done by comparing io_db["teststring"] to what's found at the start
 268     of the current file at io_db["path_out"]. On failure, set
 269     io_db["kicked_by_rival"] and raise SystemExit.
 270     """
 271     if not os.access(io_db["path_out"], os.F_OK):
 272         raise SystemExit("Server output file has disappeared.")
 273     file = open(io_db["path_out"], "r")
 274     test = file.readline().rstrip("\n")
 275     file.close()
 276     if test != io_db["teststring"]:
 277         io_db["kicked_by_rival"] = True
 278         msg = "Server test string in server output file does not match. This" \
 279               " indicates that the current server process has been " \
 280               "superseded by another one."
 281         raise SystemExit(msg)
 282
 283
 284 def read_command():
 285     """Return next newline-delimited command from server in file.
 286
 287     Keep building return string until a newline is encountered. Pause between
 288     unsuccessful reads, and after too much waiting, run server_test().
 289     """
 290     wait_on_fail = 0.03333
 291     max_wait = 5
 292     now = time.time()
 293     command = ""
 294     while True:
 295         add = io_db["file_in"].readline()
 296         if len(add) > 0:
 297             command = command + add
 298             if len(command) > 0 and "\n" == command[-1]:
 299                 command = command[:-1]
 300                 break
 301         else:
 302             time.sleep(wait_on_fail)
 303             if now + max_wait < time.time():
 304                 server_test()
 305                 now = time.time()
 306     return command
 307
 308
 309 def try_worldstate_update():
 310     """Write worldstate file if io_db["worldstate_updateable"] is set."""
 311     if io_db["worldstate_updateable"]:
 312
 313         def draw_visible_Things(map, run):
 314             for id in world_db["Things"]:
 315                 type = world_db["Things"][id]["T_TYPE"]
 316                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 317                 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
 318                 if (0 == run and not consumable and not alive) \
 319                    or (1 == run and consumable and not alive) \
 320                    or (2 == run and alive):
 321                     y = world_db["Things"][id]["T_POSY"]
 322                     x = world_db["Things"][id]["T_POSX"]
 323                     fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
 324                     if 'v' == chr(fovflag):
 325                         c = world_db["ThingTypes"][type]["TT_SYMBOL"]
 326                         map[(y * length) + x] = ord(c)
 327
 328         def write_map(string, map):
 329             for i in range(length):
 330                 line = map[i * length:(i * length) + length].decode()
 331                 string = string + line + "\n"
 332             return string
 333
 334         inventory = ""
 335         if [] == world_db["Things"][0]["T_CARRIES"]:
 336             inventory = "(none)\n"
 337         else:
 338             for id in world_db["Things"][0]["T_CARRIES"]:
 339                 type_id = world_db["Things"][id]["T_TYPE"]
 340                 name = world_db["ThingTypes"][type_id]["TT_NAME"]
 341                 inventory = inventory + name + "\n"
 342         # # 7DRL additions:  GOD_MOOD, GOD_FAVOR
 343         string = str(world_db["TURN"]) + "\n" + \
 344                  str(world_db["GOD_MOOD"]) + "\n" + \
 345                  str(world_db["GOD_FAVOR"]) + "\n" + \
 346                  str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
 347                  str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
 348                  inventory + "%\n" + \
 349                  str(world_db["Things"][0]["T_POSY"]) + "\n" + \
 350                  str(world_db["Things"][0]["T_POSX"]) + "\n" + \
 351                  str(world_db["MAP_LENGTH"]) + "\n"
 352         length = world_db["MAP_LENGTH"]
 353         fov = bytearray(b' ' * (length ** 2))
 354         for pos in range(length ** 2):
 355             if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
 356                 fov[pos] = world_db["MAP"][pos]
 357         for i in range(3):
 358             draw_visible_Things(fov, i)
 359         string = write_map(string, fov)
 360         mem = world_db["Things"][0]["T_MEMMAP"][:]
 361         for i in range(2):
 362             for mt in world_db["Things"][0]["T_MEMTHING"]:
 363                 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
 364                 if (i == 0 and not consumable) or (i == 1 and consumable):
 365                     c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
 366                     mem[(mt[1] * length) + mt[2]] = ord(c)
 367         string = write_map(string, mem)
 368         atomic_write(io_db["path_worldstate"], string, delete=False)
 369         strong_write(io_db["file_out"], "WORLD_UPDATED\n")
 370         io_db["worldstate_updateable"] = False
 371
 372
 373 def replay_game():
 374     """Replay game from record file.
 375
 376     Use opts.replay as breakpoint turn to which to replay automatically before
 377     switching to manual input by non-meta commands in server input file
 378     triggering further reads of record file. Ensure opts.replay is at least 1.
 379     Run try_worldstate_update() before each interactive obey()/read_command().
 380     """
 381     if opts.replay < 1:
 382         opts.replay = 1
 383     print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
 384           " (if so late a turn is to be found).")
 385     if not os.access(io_db["path_record"], os.F_OK):
 386         raise SystemExit("No record file found to replay.")
 387     io_db["file_record"] = open(io_db["path_record"], "r")
 388     io_db["file_record"].prefix = "record file line "
 389     io_db["file_record"].line_n = 1
 390     while world_db["TURN"] < opts.replay:
 391         line = io_db["file_record"].readline()
 392         if "" == line:
 393             break
 394         obey(line.rstrip(), io_db["file_record"].prefix
 395              + str(io_db["file_record"].line_n))
 396         io_db["file_record"].line_n = io_db["file_record"].line_n + 1
 397     while True:
 398         try_worldstate_update()
 399         obey(read_command(), "in file", replay=True)
 400
 401
 402 def play_game():
 403     """Play game by server input file commands. Before, load save file found.
 404
 405     If no save file is found, a new world is generated from the commands in the
 406     world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
 407     command and all that follow via the server input file. Run
 408     try_worldstate_update() before each interactive obey()/read_command().
 409     """
 410     if os.access(io_db["path_save"], os.F_OK):
 411         obey_lines_in_file(io_db["path_save"], "save")
 412     else:
 413         if not os.access(io_db["path_worldconf"], os.F_OK):
 414             msg = "No world config file from which to start a new world."
 415             raise SystemExit(msg)
 416         obey_lines_in_file(io_db["path_worldconf"], "world config ",
 417                            do_record=True)
 418         obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
 419     while True:
 420         try_worldstate_update()
 421         obey(read_command(), "in file", do_record=True)
 422
 423
 424 def make_map():
 425     """(Re-)make island map.
 426
 427     Let "~" represent water, "." land, "X" trees: Build island shape randomly,
 428     start with one land cell in the middle, then go into cycle of repeatedly
 429     selecting a random sea cell and transforming it into land if it is neighbor
 430     to land. The cycle ends when a land cell is due to be created at the map's
 431     border. Then put some trees on the map (TODO: more precise algorithm desc).
 432     """
 433     # 7DRL: Also add some ":" cells as land to which plants may proliferate.
 434
 435     def is_neighbor(coordinates, type):
 436         y = coordinates[0]
 437         x = coordinates[1]
 438         length = world_db["MAP_LENGTH"]
 439         ind = y % 2
 440         diag_west = x + (ind > 0)
 441         diag_east = x + (ind < (length - 1))
 442         pos = (y * length) + x
 443         if (y > 0 and diag_east
 444             and type == chr(world_db["MAP"][pos - length + ind])) \
 445            or (x < (length - 1)
 446                and type == chr(world_db["MAP"][pos + 1])) \
 447            or (y < (length - 1) and diag_east
 448                and type == chr(world_db["MAP"][pos + length + ind])) \
 449            or (y > 0 and diag_west
 450                and type == chr(world_db["MAP"][pos - length - (not ind)])) \
 451            or (x > 0
 452                and type == chr(world_db["MAP"][pos - 1])) \
 453            or (y < (length - 1) and diag_west
 454                and type == chr(world_db["MAP"][pos + length - (not ind)])):
 455             return True
 456         return False
 457
 458     world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
 459     length = world_db["MAP_LENGTH"]
 460     add_half_width = (not (length % 2)) * int(length / 2)
 461     world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
 462     while (1):
 463         y = rand.next() % length
 464         x = rand.next() % length
 465         pos = (y * length) + x
 466         if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
 467             if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
 468                 break
 469             world_db["MAP"][pos] = ord(".")
 470     n_trees = int((length ** 2) / 16)
 471     i_trees = 0
 472     while (i_trees <= n_trees):
 473         single_allowed = rand.next() % 32
 474         y = rand.next() % length
 475         x = rand.next() % length
 476         pos = (y * length) + x
 477         if "." == chr(world_db["MAP"][pos]) \
 478           and ((not single_allowed) or is_neighbor((y, x), "X")):
 479             world_db["MAP"][pos] = ord("X")
 480             i_trees += 1
 481     # This all-too-precise replica of the original C code misses iter_limit().
 482     n_colons = int((length ** 2) / 16)  # #
 483     i_colons = 0  # #
 484     while (i_colons <= n_colons):  # #
 485         single_allowed = rand.next() % 256  # #
 486         y = rand.next() % length  # #
 487         x = rand.next() % length  # #
 488         pos = (y * length) + x  # #
 489         if ("." == chr(world_db["MAP"][pos])  # #
 490           and ((not single_allowed) or is_neighbor((y, x), ":"))):  # #
 491             world_db["MAP"][pos] = ord(":")  # #
 492             i_colons += 1  # #
 493
 494
 495 def update_map_memory(t, age_map=True):
 496     """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
 497
 498     def age_some_memdepthmap_on_nonfov_cells():
 499         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
 500         # ord_v = ord("v")
 501         # ord_0 = ord("0")
 502         # ord_9 = ord("9")
 503         # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
 504         #             if not ord_v == t["fovmap"][pos]
 505         #             if ord_0 <= t["T_MEMDEPTHMAP"][pos]
 506         #             if ord_9 > t["T_MEMDEPTHMAP"][pos]
 507         #             if not rand.next() % (2 **
 508         #                                   (t["T_MEMDEPTHMAP"][pos] - 48))]:
 509         #     t["T_MEMDEPTHMAP"][pos] += 1
 510         memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
 511         fovmap = c_pointer_to_bytearray(t["fovmap"])
 512         libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
 513
 514     if not t["T_MEMMAP"]:
 515         t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 516     if not t["T_MEMDEPTHMAP"]:
 517         t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 518     ord_v = ord("v")
 519     ord_0 = ord("0")
 520     ord_space = ord(" ")
 521     for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
 522                 if ord_v == t["fovmap"][pos]]:
 523         t["T_MEMDEPTHMAP"][pos] = ord_0
 524         if ord_space == t["T_MEMMAP"][pos]:
 525             t["T_MEMMAP"][pos] = world_db["MAP"][pos]
 526     if age_map:
 527         age_some_memdepthmap_on_nonfov_cells()
 528     t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
 529                        if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
 530                                                + mt[2]]]
 531     for id in [id for id in world_db["Things"]
 532                if not world_db["Things"][id]["carried"]]:
 533         type = world_db["Things"][id]["T_TYPE"]
 534         if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
 535             y = world_db["Things"][id]["T_POSY"]
 536             x = world_db["Things"][id]["T_POSX"]
 537             if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
 538                 t["T_MEMTHING"].append((type, y, x))
 539
 540
 541 def set_world_inactive():
 542     """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
 543     server_test()
 544     if os.access(io_db["path_worldstate"], os.F_OK):
 545         os.remove(io_db["path_worldstate"])
 546     world_db["WORLD_ACTIVE"] = 0
 547
 548
 549 def integer_test(val_string, min, max=None):
 550     """Return val_string if possible integer >= min and <= max, else None."""
 551     try:
 552         val = int(val_string)
 553         if val < min or (max is not None and val > max):
 554             raise ValueError
 555         return val
 556     except ValueError:
 557         msg = "Ignoring: Please use integer >= " + str(min)
 558         if max is not None:
 559             msg += " and <= " + str(max)
 560         msg += "."
 561         print(msg)
 562         return None
 563
 564
 565 def setter(category, key, min, max=None):
 566     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
 567     if category is None:
 568         def f(val_string):
 569             val = integer_test(val_string, min, max)
 570             if None != val:
 571                 world_db[key] = val
 572     else:
 573         if category == "Thing":
 574             id_store = command_tid
 575             decorator = test_Thing_id
 576         elif category == "ThingType":
 577             id_store = command_ttid
 578             decorator = test_ThingType_id
 579         elif category == "ThingAction":
 580             id_store = command_taid
 581             decorator = test_ThingAction_id
 582
 583         @decorator
 584         def f(val_string):
 585             val = integer_test(val_string, min, max)
 586             if None != val:
 587                 world_db[category + "s"][id_store.id][key] = val
 588     return f
 589
 590
 591 def build_fov_map(t):
 592     """Build Thing's FOV map."""
 593     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
 594     fovmap = c_pointer_to_bytearray(t["fovmap"])
 595     map = c_pointer_to_bytearray(world_db["MAP"])
 596     if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
 597         raise RuntimeError("Malloc error in build_fov_Map().")
 598
 599
 600 def decrement_lifepoints(t):
 601     """Decrement t's lifepoints by 1, and if to zero, corpse it.
 602
 603     If t is the player avatar, only blank its fovmap, so that the client may
 604     still display memory data. On non-player things, erase fovmap and memory.
 605     Dying actors drop all their things.
 606     """
 607     # # 7DRL: also decrements God's mood; deaths heavily so
 608     # # 7DRL: return 1 if death, else 0
 609     t["T_LIFEPOINTS"] -= 1
 610     world_db["GOD_MOOD"] -= 1  # #
 611     if 0 == t["T_LIFEPOINTS"]:
 612         sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
 613         world_db["GOD_MOOD"] -= sadness  # #
 614         for id in t["T_CARRIES"]:
 615             t["T_CARRIES"].remove(id)
 616             world_db["Things"][id]["T_POSY"] = t["T_POSY"]
 617             world_db["Things"][id]["T_POSX"] = t["T_POSX"]
 618             world_db["Things"][id]["carried"] = False
 619         t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
 620         if world_db["Things"][0] == t:
 621             t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 622             strong_write(io_db["file_out"], "LOG You die.\n")
 623         else:
 624             t["fovmap"] = False
 625             t["T_MEMMAP"] = False
 626             t["T_MEMDEPTHMAP"] = False
 627             t["T_MEMTHING"] = []
 628         return sadness  # #
 629     return 0  # #
 630
 631
 632 def add_gods_favor(i): # #
 633     """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
 634     def favor_multiplier(i):
 635         x = 100
 636         threshold = math.e * x
 637         mood = world_db["GOD_MOOD"]
 638         if i > 0:
 639             if mood > threshold:
 640                 i = i * math.log(mood / x)
 641             elif -mood > threshold:
 642                 i = i / math.log(-mood / x)
 643         elif i < 0:
 644             if -mood > threshold:
 645                 i = i * math.log(-mood / x)
 646             if mood > threshold:
 647                 i = i / math.log(mood / x)
 648         return int(i)
 649     world_db["GOD_FAVOR"] += favor_multiplier(i)
 650
 651
 652 def mv_yx_in_dir_legal(dir, y, x):
 653     """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
 654     dir_c = dir.encode("ascii")[0]
 655     test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
 656     if -1 == test:
 657         raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
 658     return (test, libpr.result_y(), libpr.result_x())
 659
 660
 661 def actor_wait(t):
 662     """Make t do nothing (but loudly, if player avatar)."""
 663     if t == world_db["Things"][0]:
 664         strong_write(io_db["file_out"], "LOG You wait.\n")
 665
 666
 667 def actor_move(t):
 668     """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
 669     # # 7DRL: Player wounding (worse: killing) others will lower God's favor.
 670     passable = False
 671     move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
 672                                      t["T_POSY"], t["T_POSX"])
 673     if 1 == move_result[0]:
 674         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
 675         passable = "." == chr(world_db["MAP"][pos]) or \
 676                    ":" == chr(world_db["MAP"][pos])  # #
 677         hitted = [id for id in world_db["Things"]
 678                   if world_db["Things"][id] != t
 679                   if world_db["Things"][id]["T_LIFEPOINTS"]
 680                   if world_db["Things"][id]["T_POSY"] == move_result[1]
 681                   if world_db["Things"][id]["T_POSX"] == move_result[2]]
 682         if len(hitted):
 683             hit_id = hitted[0]
 684             if t == world_db["Things"][0]:
 685                 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
 686                 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
 687                 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
 688                                                 + ".\n")
 689                 add_gods_favor(-1)  # #
 690             elif 0 == hit_id:
 691                 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 692                 strong_write(io_db["file_out"], "LOG " + hitter_name +
 693                                                 " wounds you.\n")
 694             test = decrement_lifepoints(world_db["Things"][hit_id])  # #(test=)
 695             if test and t == world_db["Things"][0]:  # #
 696                 add_gods_favor(-test)  # #
 697             return
 698     dir = [dir for dir in directions_db
 699            if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
 700     if passable:
 701         t["T_POSY"] = move_result[1]
 702         t["T_POSX"] = move_result[2]
 703         for id in t["T_CARRIES"]:
 704             world_db["Things"][id]["T_POSY"] = move_result[1]
 705             world_db["Things"][id]["T_POSX"] = move_result[2]
 706         build_fov_map(t)
 707         if t == world_db["Things"][0]:
 708             strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
 709     elif t == world_db["Things"][0]:
 710         strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
 711
 712
 713 def actor_pick_up(t):
 714     """Make t pick up (topmost?) Thing from ground into inventory."""
 715     # Topmostness is actually not defined so far. Picks most nutritious Thing.
 716     # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
 717     used_slots = len(t["T_CARRIES"]) # #
 718     if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
 719         ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
 720                if not world_db["Things"][id]["carried"]
 721                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
 722                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
 723         if len(ids):
 724             highest_id = ids[0]
 725             nutritious = 0
 726             for id in ids:
 727                 type = world_db["Things"][id]["T_TYPE"]
 728                 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
 729                     nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 730                     highest_id = id
 731             world_db["Things"][highest_id]["carried"] = True
 732             if (t != world_db["Things"][0] and  # #
 733                 world_db["Things"][highest_id]["T_PLAYERDROP"]):  # #
 734                 x = world_db["Things"][highest_id]["T_TYPE"]
 735                 score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32  # #
 736                 add_gods_favor(score)  # #
 737                 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0  # #
 738             t["T_CARRIES"].append(highest_id)
 739             if t == world_db["Things"][0]:
 740                 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
 741         elif t == world_db["Things"][0]:
 742             err = "You try to pick up an object, but there is none."
 743             strong_write(io_db["file_out"], "LOG " + err + "\n")
 744     elif t == world_db["Things"][0]: # #
 745         strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
 746                                         "No storage room to carry more.\n") # #
 747
 748
 749 def actor_drop(t):
 750     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
 751     # TODO: Handle case where T_ARGUMENT matches nothing.
 752     if len(t["T_CARRIES"]):
 753         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 754         t["T_CARRIES"].remove(id)
 755         world_db["Things"][id]["carried"] = False
 756         if t == world_db["Things"][0]:
 757             strong_write(io_db["file_out"], "LOG You drop an object.\n")
 758             world_db["Things"][id]["T_PLAYERDROP"] = 1  # #
 759     elif t == world_db["Things"][0]:
 760         err = "You try to drop an object, but you own none."
 761         strong_write(io_db["file_out"], "LOG " + err + "\n")
 762
 763
 764 def actor_use(t):
 765     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
 766     # TODO: Handle case where T_ARGUMENT matches nothing.
 767     if len(t["T_CARRIES"]):
 768         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 769         type = world_db["Things"][id]["T_TYPE"]
 770         if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
 771             t["T_CARRIES"].remove(id)
 772             del world_db["Things"][id]
 773             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 774             if t == world_db["Things"][0]:
 775                 strong_write(io_db["file_out"],
 776                              "LOG You consume this object.\n")
 777         elif t == world_db["Things"][0]:
 778             strong_write(io_db["file_out"],
 779                          "LOG You try to use this object, but fail.\n")
 780     elif t == world_db["Things"][0]:
 781         strong_write(io_db["file_out"],
 782                      "LOG You try to use an object, but you own none.\n")
 783
 784
 785 def thingproliferation(t, prol_map):
 786     """To chance of 1/TT_PROLIFERATE,create  t offspring in open neighbor cell.
 787
 788     Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
 789     marked "." in prol_map. If there are several map cell candidates, one is
 790     selected randomly.
 791     """
 792     # # 7DRL: success increments God's mood
 793     # # 7DRL: Things proliferate only on ":" ground.
 794     prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
 795     if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
 796         candidates = []
 797         for dir in [directions_db[key] for key in directions_db]:
 798             mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
 799             if mv_result[0] and ord(":") == prol_map[mv_result[1]  # #
 800             # if mv_result[0] and ord(".") == prol_map[mv_result[1]
 801                                                      * world_db["MAP_LENGTH"]
 802                                                      + mv_result[2]]:
 803                 candidates.append((mv_result[1], mv_result[2]))
 804         if len(candidates):
 805             i = rand.next() % len(candidates)
 806             id = id_setter(-1, "Things")
 807             newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
 808             world_db["Things"][id] = newT
 809             world_db["GOD_MOOD"] += 1  # #
 810
 811
 812 def try_healing(t):
 813     """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
 814
 815     On success, decrease satiation score by 32.
 816     """
 817     # # 7DRL: Successful heals increment God's mood.
 818     if t["T_SATIATION"] > 0 \
 819        and t["T_LIFEPOINTS"] < \
 820            world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
 821        and 0 == (rand.next() % 31) \
 822        and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
 823                               if world_db["ThingActions"][id]["TA_NAME"] ==
 824                                  "wait"][0]:
 825         t["T_LIFEPOINTS"] += 1
 826         world_db["GOD_MOOD"] += 1  # #
 827         t["T_SATIATION"] -= 32
 828         if t == world_db["Things"][0]:
 829             strong_write(io_db["file_out"], "LOG You heal.\n")
 830
 831
 832 def hunger(t):
 833     """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
 834     if t["T_SATIATION"] > -32768:
 835         t["T_SATIATION"] -= 1
 836     testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
 837     if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
 838         raise RuntimeError("A thing that should not hunger is hungering.")
 839     stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
 840     if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
 841         if t == world_db["Things"][0]:
 842             strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
 843         decrement_lifepoints(t)
 844
 845
 846 def get_dir_to_target(t, filter):
 847     """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
 848
 849     The path-wise nearest target is chosen, via the shortest available path.
 850     Target must not be t. On succcess, return positive value, else False.
 851     Filters:
 852     "a": Thing in FOV is below a certain distance, animate, but of ThingType
 853          that is not t's, and starts out weaker than t is; build path as
 854          avoiding things of t's ThingType
 855     "f": neighbor cell (not inhabited by any animate Thing) further away from
 856          animate Thing not further than x steps away and in FOV and of a
 857          ThingType that is not t's, and starts out stronger or as strong as t
 858          is currently; or (cornered), if no such flight cell, but Thing of
 859          above criteria is too near,1 a cell closer to it, or, if less near,
 860          just wait
 861     "c": Thing in memorized map is consumable
 862     "s": memory map cell with greatest-reachable degree of unexploredness
 863     """
 864
 865     def zero_score_map_where_char_on_memdepthmap(c):
 866         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
 867         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
 868         #           if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
 869         #     set_map_score(i, 0)
 870         map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
 871         if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
 872             raise RuntimeError("No score map allocated for "
 873                                "zero_score_map_where_char_on_memdepthmap().")
 874
 875     def set_map_score(pos, score):
 876         test = libpr.set_map_score(pos, score)
 877         if test:
 878             raise RuntimeError("No score map allocated for set_map_score().")
 879
 880     def get_map_score(pos):
 881         result = libpr.get_map_score(pos)
 882         if result < 0:
 883             raise RuntimeError("No score map allocated for get_map_score().")
 884         return result
 885
 886     def seeing_thing():
 887         if t["fovmap"] and ("a" == filter or "f" == filter):
 888             for id in world_db["Things"]:
 889                 Thing = world_db["Things"][id]
 890                 if Thing != t and Thing["T_LIFEPOINTS"] and \
 891                    t["T_TYPE"] != Thing["T_TYPE"] and \
 892                    'v' == chr(t["fovmap"][(Thing["T_POSY"]
 893                                           * world_db["MAP_LENGTH"])
 894                                           + Thing["T_POSX"]]):
 895                     ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
 896                     if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
 897                                           t["T_LIFEPOINTS"]) \
 898                        or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
 899                                              t["T_LIFEPOINTS"]):
 900                         return True
 901         elif t["T_MEMMAP"] and "c" == filter:
 902             for mt in t["T_MEMTHING"]:
 903                 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
 904                                          + mt[2]]) \
 905                    and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
 906                     return True
 907         return False
 908
 909     def set_cells_passable_on_memmap_to_65534_on_scoremap():
 910         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
 911         # ord_dot = ord(".")
 912         # memmap = t["T_MEMMAP"]
 913         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
 914         #            if ord_dot == memmap[i]]:
 915         #     set_map_score(i, 65534) # i.e. 65535-1
 916         map = c_pointer_to_bytearray(t["T_MEMMAP"])
 917         if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
 918             raise RuntimeError("No score map allocated for "
 919                         "set_cells_passable_on_memmap_to_65534_on_scoremap().")
 920
 921     def init_score_map():
 922         test = libpr.init_score_map()
 923         if test:
 924             raise RuntimeError("Malloc error in init_score_map().")
 925         ord_v = ord("v")
 926         ord_blank = ord(" ")
 927         set_cells_passable_on_memmap_to_65534_on_scoremap()
 928         if "a" == filter:
 929             for id in world_db["Things"]:
 930                 Thing = world_db["Things"][id]
 931                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
 932                       + Thing["T_POSX"]
 933                 if t != Thing and Thing["T_LIFEPOINTS"] and \
 934                    t["T_TYPE"] != Thing["T_TYPE"] and \
 935                    ord_v == t["fovmap"][pos] and \
 936                    t["T_LIFEPOINTS"] > \
 937                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
 938                     set_map_score(pos, 0)
 939                 elif t["T_TYPE"] == Thing["T_TYPE"]:
 940                     set_map_score(pos, 65535)
 941         elif "f" == filter:
 942             for id in [id for id in world_db["Things"]
 943                        if world_db["Things"][id]["T_LIFEPOINTS"]]:
 944                 Thing = world_db["Things"][id]
 945                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
 946                       + Thing["T_POSX"]
 947                 if t["T_TYPE"] != Thing["T_TYPE"] and \
 948                    ord_v == t["fovmap"][pos] and \
 949                    t["T_LIFEPOINTS"] <= \
 950                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
 951                     set_map_score(pos, 0)
 952         elif "c" == filter:
 953             for mt in [mt for mt in t["T_MEMTHING"]
 954                        if ord_blank != t["T_MEMMAP"][mt[1]
 955                                                     * world_db["MAP_LENGTH"]
 956                                                     + mt[2]]
 957                        if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
 958                 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
 959         elif "s" == filter:
 960             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
 961
 962     def rand_target_dir(neighbors, cmp, dirs):
 963         candidates = []
 964         n_candidates = 0
 965         for i in range(len(dirs)):
 966             if cmp == neighbors[i]:
 967                 candidates.append(dirs[i])
 968                 n_candidates += 1
 969         return candidates[rand.next() % n_candidates] if n_candidates else 0
 970
 971     def get_neighbor_scores(dirs, eye_pos):
 972         scores = []
 973         if libpr.ready_neighbor_scores(eye_pos):
 974             raise RuntimeError("No score map allocated for " +
 975                                "ready_neighbor_scores.()")
 976         for i in range(len(dirs)):
 977             scores.append(libpr.get_neighbor_score(i))
 978         return scores
 979
 980     def get_dir_from_neighbors():
 981         dir_to_target = False
 982         dirs = "edcxsw"
 983         eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
 984         neighbors = get_neighbor_scores(dirs, eye_pos)
 985         if "f" == filter:
 986             inhabited = [world_db["Things"][id]["T_POSY"]
 987                          * world_db["MAP_LENGTH"]
 988                          + world_db["Things"][id]["T_POSX"]
 989                          for id in world_db["Things"]
 990                          if world_db["Things"][id]["T_LIFEPOINTS"]]
 991             for i in range(len(dirs)):
 992                 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
 993                 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
 994                           + libpr.result_x()
 995                 for pos in [pos for pos in inhabited if pos == pos_cmp]:
 996                     neighbors[i] = 65535
 997                     break
 998         minmax_start = 0 if "f" == filter else 65535 - 1
 999         minmax_neighbor = minmax_start
1000         for i in range(len(dirs)):
1001             if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1002                 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1003                or ("f" != filter and minmax_neighbor > neighbors[i]):
1004                 minmax_neighbor = neighbors[i]
1005         if minmax_neighbor != minmax_start:
1006             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1007         if "f" == filter:
1008             if not dir_to_target:
1009                 if 1 == get_map_score(eye_pos):
1010                     dir_to_target = rand_target_dir(neighbors, 0, dirs)
1011                 elif 3 >= get_map_score(eye_pos):
1012                     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1013                                       if
1014                                       world_db["ThingActions"][id]["TA_NAME"]
1015                                          == "wait"][0]
1016                     return 1
1017             elif dir_to_target and 3 < get_map_score(eye_pos):
1018                 dir_to_target = 0
1019         elif "a" == filter and 10 <= get_map_score(eye_pos):
1020             dir_to_target = 0
1021         return dir_to_target
1022
1023     dir_to_target = False
1024     mem_depth_c = b' '
1025     run_i = 9 + 1 if "s" == filter else 1
1026     while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1027         run_i -= 1
1028         init_score_map()
1029         mem_depth_c = b'9' if b' ' == mem_depth_c \
1030                            else bytes([mem_depth_c[0] - 1])
1031         if libpr.dijkstra_map():
1032             raise RuntimeError("No score map allocated for dijkstra_map().")
1033         dir_to_target = get_dir_from_neighbors()
1034         libpr.free_score_map()
1035         if dir_to_target and str == type(dir_to_target):
1036             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1037                               if world_db["ThingActions"][id]["TA_NAME"]
1038                                  == "move"][0]
1039             t["T_ARGUMENT"] = ord(dir_to_target)
1040     return dir_to_target
1041
1042
1043 def standing_on_consumable(t):
1044     """Return True/False whether t is standing on a consumable."""
1045     for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1046                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1047                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1048                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1049                           ["TT_CONSUMABLE"]]:
1050         return True
1051     return False
1052
1053
1054 def get_inventory_slot_to_consume(t):
1055     """Return slot Id of strongest consumable in t's inventory, else -1."""
1056     cmp_consumability = 0
1057     selection = -1
1058     i = 0
1059     for id in t["T_CARRIES"]:
1060         type = world_db["Things"][id]["T_TYPE"]
1061         if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
1062             cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1063             selection = i
1064         i += 1
1065     return selection
1066
1067
1068 def ai(t):
1069     """Determine next command/argment for actor t via AI algorithms.
1070
1071     AI will look for, and move towards, enemies (animate Things not of their
1072     own ThingType); if they see none, they will consume consumables in their
1073     inventory; if there are none, they will pick up what they stand on if they
1074     stand on consumables; if they stand on none, they will move towards the
1075     next consumable they see or remember on the map; if they see or remember
1076     none, they will explore parts of the map unseen since ever or for at least
1077     one turn; if there is nothing to explore, they will simply wait.
1078     """
1079     # # 7DRL add: Don't pick up or search things when inventory is full.
1080     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1081                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1082     if not get_dir_to_target(t, "f"):
1083         sel = get_inventory_slot_to_consume(t)
1084         if -1 != sel:
1085             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1086                               if world_db["ThingActions"][id]["TA_NAME"]
1087                                  == "use"][0]
1088             t["T_ARGUMENT"] = sel
1089         elif standing_on_consumable(t) \
1090              and (len(t["T_CARRIES"]) < # #
1091                  world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1092             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1093                               if world_db["ThingActions"][id]["TA_NAME"]
1094                                  == "pick_up"][0]
1095         elif (not
1096               (len(t["T_CARRIES"]) < # #
1097                 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1098                and get_dir_to_target(t, "c"))) and \
1099              (not get_dir_to_target(t, "a")):
1100             get_dir_to_target(t, "s")
1101
1102
1103 def turn_over():
1104     """Run game world and its inhabitants until new player input expected."""
1105     id = 0
1106     whilebreaker = False
1107     while world_db["Things"][0]["T_LIFEPOINTS"]:
1108         proliferable_map = world_db["MAP"][:]
1109         for id in [id for id in world_db["Things"]
1110                    if not world_db["Things"][id]["carried"]]:
1111             y = world_db["Things"][id]["T_POSY"]
1112             x = world_db["Things"][id]["T_POSX"]
1113             proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1114         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1115             if not id in world_db["Things"] or \
1116                world_db["Things"][id]["carried"]:   # May have been consumed or
1117                 continue                            # picked up during turn …
1118             Thing = world_db["Things"][id]
1119             if Thing["T_LIFEPOINTS"]:
1120                 if not Thing["T_COMMAND"]:
1121                     update_map_memory(Thing)
1122                     if 0 == id:
1123                         whilebreaker = True
1124                         break
1125                     ai(Thing)
1126                 try_healing(Thing)
1127                 Thing["T_PROGRESS"] += 1
1128                 taid = [a for a in world_db["ThingActions"]
1129                           if a == Thing["T_COMMAND"]][0]
1130                 ThingAction = world_db["ThingActions"][taid]
1131                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1132                     eval("actor_" + ThingAction["TA_NAME"])(Thing)
1133                     Thing["T_COMMAND"] = 0
1134                     Thing["T_PROGRESS"] = 0
1135                 hunger(Thing)
1136             thingproliferation(Thing, proliferable_map)
1137         if whilebreaker:
1138             break
1139         world_db["TURN"] += 1
1140
1141
1142 def new_Thing(type, pos=(0, 0)):
1143     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1144     thing = {
1145         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1146         "T_ARGUMENT": 0,
1147         "T_PROGRESS": 0,
1148         "T_SATIATION": 0,
1149         "T_COMMAND": 0,
1150         "T_PLAYERDROP": 0,  # #
1151         "T_TYPE": type,
1152         "T_POSY": pos[0],
1153         "T_POSX": pos[1],
1154         "T_CARRIES": [],
1155         "carried": False,
1156         "T_MEMTHING": [],
1157         "T_MEMMAP": False,
1158         "T_MEMDEPTHMAP": False,
1159         "fovmap": False
1160     }
1161     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1162         build_fov_map(thing)
1163     return thing
1164
1165
1166 def id_setter(id, category, id_store=False, start_at_1=False):
1167     """Set ID of object of category to manipulate ID unused? Create new one.
1168
1169     The ID is stored as id_store.id (if id_store is set). If the integer of the
1170     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1171     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1172     always returned when no new object is created, otherwise the new object's
1173     ID.
1174     """
1175     min = 0 if start_at_1 else -1
1176     if str == type(id):
1177         id = integer_test(id, min)
1178     if None != id:
1179         if id in world_db[category]:
1180             if id_store:
1181                 id_store.id = id
1182             return None
1183         else:
1184             if (start_at_1 and 0 == id) \
1185                or ((not start_at_1) and (id < 0)):
1186                 id = 0 if start_at_1 else -1
1187                 while 1:
1188                     id = id + 1
1189                     if id not in world_db[category]:
1190                         break
1191             if id_store:
1192                 id_store.id = id
1193     return id
1194
1195
1196 def command_ping():
1197     """Send PONG line to server output file."""
1198     strong_write(io_db["file_out"], "PONG\n")
1199
1200
1201 def command_quit():
1202     """Abort server process."""
1203     if None == opts.replay:
1204         if world_db["WORLD_ACTIVE"]:
1205             save_world()
1206         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1207     raise SystemExit("received QUIT command")
1208
1209
1210 def command_thingshere(str_y, str_x):
1211     """Write to out file list of Things known to player at coordinate y, x."""
1212     if world_db["WORLD_ACTIVE"]:
1213         y = integer_test(str_y, 0, 255)
1214         x = integer_test(str_x, 0, 255)
1215         length = world_db["MAP_LENGTH"]
1216         if None != y and None != x and y < length and x < length:
1217             pos = (y * world_db["MAP_LENGTH"]) + x
1218             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1219             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1220                 for id in world_db["Things"]:
1221                     if y == world_db["Things"][id]["T_POSY"] \
1222                        and x == world_db["Things"][id]["T_POSX"] \
1223                        and not world_db["Things"][id]["carried"]:
1224                         type = world_db["Things"][id]["T_TYPE"]
1225                         name = world_db["ThingTypes"][type]["TT_NAME"]
1226                         strong_write(io_db["file_out"], name + "\n")
1227             else:
1228                 for mt in world_db["Things"][0]["T_MEMTHING"]:
1229                     if y == mt[1] and x == mt[2]:
1230                         name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1231                         strong_write(io_db["file_out"], name + "\n")
1232             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1233         else:
1234             print("Ignoring: Invalid map coordinates.")
1235     else:
1236         print("Ignoring: Command only works on existing worlds.")
1237
1238
1239 def play_commander(action, args=False):
1240     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1241
1242     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1243     """
1244
1245     def set_command():
1246         id = [x for x in world_db["ThingActions"]
1247                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1248         world_db["Things"][0]["T_COMMAND"] = id
1249         turn_over()
1250
1251     def set_command_and_argument_int(str_arg):
1252         val = integer_test(str_arg, 0, 255)
1253         if None != val:
1254             world_db["Things"][0]["T_ARGUMENT"] = val
1255             set_command()
1256
1257     def set_command_and_argument_movestring(str_arg):
1258         if str_arg in directions_db:
1259             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1260             set_command()
1261         else:
1262             print("Ignoring: Argument must be valid direction string.")
1263
1264     if action == "move":
1265         return set_command_and_argument_movestring
1266     elif args:
1267         return set_command_and_argument_int
1268     else:
1269         return set_command
1270
1271
1272 def command_seedrandomness(seed_string):
1273     """Set rand seed to int(seed_string)."""
1274     val = integer_test(seed_string, 0, 4294967295)
1275     if None != val:
1276         rand.seed = val
1277
1278
1279 def command_makeworld(seed_string):
1280     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1281
1282     Seed rand with seed. Do more only with a "wait" ThingAction and
1283     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1284     world_db["Things"] emptied, call make_map() and set
1285     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1286     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1287     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1288     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1289     """
1290
1291     # def free_pos(plant=False):
1292     def free_pos(plant=False):  # #
1293         i = 0
1294         while 1:
1295             err = "Space to put thing on too hard to find. Map too small?"
1296             while 1:
1297                 y = rand.next() % world_db["MAP_LENGTH"]
1298                 x = rand.next() % world_db["MAP_LENGTH"]
1299                 pos = y * world_db["MAP_LENGTH"] + x;
1300                 if (not plant  # #
1301                     and "." == chr(world_db["MAP"][pos])) \
1302                    or ":" == chr(world_db["MAP"][pos]):  # #
1303                     break
1304                 i += 1
1305                 if i == 65535:
1306                     raise SystemExit(err)
1307             # Replica of C code, wrongly ignores animatedness of new Thing.
1308             pos_clear = (0 == len([id for id in world_db["Things"]
1309                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1310                                    if world_db["Things"][id]["T_POSY"] == y
1311                                    if world_db["Things"][id]["T_POSX"] == x]))
1312             if pos_clear:
1313                 break
1314         return (y, x)
1315
1316     val = integer_test(seed_string, 0, 4294967295)
1317     if None == val:
1318         return
1319     rand.seed = val
1320     player_will_be_generated = False
1321     playertype = world_db["PLAYER_TYPE"]
1322     for ThingType in world_db["ThingTypes"]:
1323         if playertype == ThingType:
1324             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1325                 player_will_be_generated = True
1326             break
1327     if not player_will_be_generated:
1328         print("Ignoring: No player type with start number >0 defined.")
1329         return
1330     wait_action = False
1331     for ThingAction in world_db["ThingActions"]:
1332         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1333             wait_action = True
1334     if not wait_action:
1335         print("Ignoring: No thing action with name 'wait' defined.")
1336         return
1337     world_db["Things"] = {}
1338     make_map()
1339     world_db["WORLD_ACTIVE"] = 1
1340     world_db["TURN"] = 1
1341     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1342         id = id_setter(-1, "Things")
1343         world_db["Things"][id] = new_Thing(playertype, free_pos())
1344     if not world_db["Things"][0]["fovmap"]:
1345         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1346         world_db["Things"][0]["fovmap"] = empty_fovmap
1347     update_map_memory(world_db["Things"][0])
1348     for type in world_db["ThingTypes"]:
1349         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1350             if type != playertype:
1351                 id = id_setter(-1, "Things")
1352                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1353                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1354     world_db["ALTAR"] = free_pos()  # #
1355     strong_write(io_db["file_out"], "NEW_WORLD\n")
1356
1357
1358 def command_altar(str_y, str_x):  # #
1359     """Set position of Island God's altar."""
1360     y = integer_test(str_y, 0, 255)
1361     x = integer_test(str_x, 0, 255)
1362     if None != y and None != x:
1363         if y < world_db["MAP_LENGTH"] and x < world_db["MAP_LENGTH"]:
1364             world_db["ALTAR"] = (y, x)
1365         else:
1366             print("Ignoring: Position is outside of map.")
1367
1368
1369 def command_maplength(maplength_string):
1370     """Redefine map length. Invalidate map, therefore lose all things on it."""
1371     val = integer_test(maplength_string, 1, 256)
1372     if None != val:
1373         world_db["MAP_LENGTH"] = val
1374         world_db["MAP"] = False
1375         set_world_inactive()
1376         world_db["Things"] = {}
1377         libpr.set_maplength(val)
1378
1379
1380 def command_worldactive(worldactive_string):
1381     """Toggle world_db["WORLD_ACTIVE"] if possible.
1382
1383     An active world can always be set inactive. An inactive world can only be
1384     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1385     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1386     """
1387     # 7DRL: Altar position must also be set for world activation.
1388     val = integer_test(worldactive_string, 0, 1)
1389     if None != val:
1390         if 0 != world_db["WORLD_ACTIVE"]:
1391             if 0 == val:
1392                 set_world_inactive()
1393             else:
1394                 print("World already active.")
1395         elif 0 == world_db["WORLD_ACTIVE"]:
1396             wait_exists = False
1397             for ThingAction in world_db["ThingActions"]:
1398                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1399                     wait_exists = True
1400                     break
1401             player_exists = False
1402             for Thing in world_db["Things"]:
1403                 if 0 == Thing:
1404                     player_exists = True
1405                     break
1406             if wait_exists and player_exists and world_db["MAP"] \
1407                 and  world_db["ALTAR"]:  # #
1408                 for id in world_db["Things"]:
1409                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1410                         build_fov_map(world_db["Things"][id])
1411                         if 0 == id:
1412                             update_map_memory(world_db["Things"][id], False)
1413                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1414                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1415                     world_db["Things"][0]["fovmap"] = empty_fovmap
1416                 world_db["WORLD_ACTIVE"] = 1
1417             else:
1418                 print("Ignoring: Not all conditions for world activation met.")
1419
1420
1421 def test_for_id_maker(object, category):
1422     """Return decorator testing for object having "id" attribute."""
1423     def decorator(f):
1424         def helper(*args):
1425             if hasattr(object, "id"):
1426                 f(*args)
1427             else:
1428                 print("Ignoring: No " + category +
1429                       " defined to manipulate yet.")
1430         return helper
1431     return decorator
1432
1433
1434 def command_tid(id_string):
1435     """Set ID of Thing to manipulate. ID unused? Create new one.
1436
1437     Default new Thing's type to the first available ThingType, others: zero.
1438     """
1439     id = id_setter(id_string, "Things", command_tid)
1440     if None != id:
1441         if world_db["ThingTypes"] == {}:
1442             print("Ignoring: No ThingType to settle new Thing in.")
1443             return
1444         type = list(world_db["ThingTypes"].keys())[0]
1445         world_db["Things"][id] = new_Thing(type)
1446
1447
1448 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1449
1450
1451 @test_Thing_id
1452 def command_tcommand(str_int):
1453     """Set T_COMMAND of selected Thing."""
1454     val = integer_test(str_int, 0)
1455     if None != val:
1456         if 0 == val or val in world_db["ThingActions"]:
1457             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1458         else:
1459             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1460
1461
1462 @test_Thing_id
1463 def command_ttype(str_int):
1464     """Set T_TYPE of selected Thing."""
1465     val = integer_test(str_int, 0)
1466     if None != val:
1467         if val in world_db["ThingTypes"]:
1468             world_db["Things"][command_tid.id]["T_TYPE"] = val
1469         else:
1470             print("Ignoring: ThingType ID belongs to no known ThingType.")
1471
1472
1473 @test_Thing_id
1474 def command_tcarries(str_int):
1475     """Append int(str_int) to T_CARRIES of selected Thing.
1476
1477     The ID int(str_int) must not be of the selected Thing, and must belong to a
1478     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1479     """
1480     val = integer_test(str_int, 0)
1481     if None != val:
1482         if val == command_tid.id:
1483             print("Ignoring: Thing cannot carry itself.")
1484         elif val in world_db["Things"] \
1485              and not world_db["Things"][val]["carried"]:
1486             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1487             world_db["Things"][val]["carried"] = True
1488         else:
1489             print("Ignoring: Thing not available for carrying.")
1490     # Note that the whole carrying structure is different from the C version:
1491     # Carried-ness is marked by a "carried" flag, not by Things containing
1492     # Things internally.
1493
1494
1495 @test_Thing_id
1496 def command_tmemthing(str_t, str_y, str_x):
1497     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1498
1499     The type must fit to an existing ThingType, and the position into the map.
1500     """
1501     type = integer_test(str_t, 0)
1502     posy = integer_test(str_y, 0, 255)
1503     posx = integer_test(str_x, 0, 255)
1504     if None != type and None != posy and None != posx:
1505         if type not in world_db["ThingTypes"] \
1506            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1507             print("Ignoring: Illegal value for thing type or position.")
1508         else:
1509             memthing = (type, posy, posx)
1510             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1511
1512
1513 def setter_map(maptype):
1514     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1515
1516     If no map of maptype exists yet, initialize it with ' ' bytes first.
1517     """
1518
1519     def valid_map_line(str_int, mapline):
1520         val = integer_test(str_int, 0, 255)
1521         if None != val:
1522             if val >= world_db["MAP_LENGTH"]:
1523                 print("Illegal value for map line number.")
1524             elif len(mapline) != world_db["MAP_LENGTH"]:
1525                 print("Map line length is unequal map width.")
1526             else:
1527                 return val
1528         return None
1529
1530     def nonThingMap_helper(str_int, mapline):
1531         val = valid_map_line(str_int, mapline)
1532         if None != val:
1533             length = world_db["MAP_LENGTH"]
1534             if not world_db["MAP"]:
1535                 map = bytearray(b' ' * (length ** 2))
1536             else:
1537                 map = world_db["MAP"]
1538             map[val * length:(val * length) + length] = mapline.encode()
1539             if not world_db["MAP"]:
1540                 world_db["MAP"] = map
1541
1542     @test_Thing_id
1543     def ThingMap_helper(str_int, mapline):
1544         val = valid_map_line(str_int, mapline)
1545         if None != val:
1546             length = world_db["MAP_LENGTH"]
1547             if not world_db["Things"][command_tid.id][maptype]:
1548                 map = bytearray(b' ' * (length ** 2))
1549             else:
1550                 map = world_db["Things"][command_tid.id][maptype]
1551             map[val * length:(val * length) + length] = mapline.encode()
1552             if not world_db["Things"][command_tid.id][maptype]:
1553                 world_db["Things"][command_tid.id][maptype] = map
1554
1555     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1556
1557
1558 def setter_tpos(axis):
1559     """Generate setter for T_POSX or  T_POSY of selected Thing.
1560
1561     If world is active, rebuilds animate things' fovmap, player's memory map.
1562     """
1563     @test_Thing_id
1564     def helper(str_int):
1565         val = integer_test(str_int, 0, 255)
1566         if None != val:
1567             if val < world_db["MAP_LENGTH"]:
1568                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1569                 if world_db["WORLD_ACTIVE"] \
1570                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1571                     build_fov_map(world_db["Things"][command_tid.id])
1572                     if 0 == command_tid.id:
1573                         update_map_memory(world_db["Things"][command_tid.id])
1574             else:
1575                 print("Ignoring: Position is outside of map.")
1576     return helper
1577
1578
1579 def command_ttid(id_string):
1580     """Set ID of ThingType to manipulate. ID unused? Create new one.
1581
1582     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1583     """
1584     id = id_setter(id_string, "ThingTypes", command_ttid)
1585     if None != id:
1586         world_db["ThingTypes"][id] = {
1587             "TT_NAME": "(none)",
1588             "TT_CONSUMABLE": 0,
1589             "TT_LIFEPOINTS": 0,
1590             "TT_PROLIFERATE": 0,
1591             "TT_START_NUMBER": 0,
1592             "TT_STORAGE": 0, # #
1593             "TT_SYMBOL": "?",
1594             "TT_CORPSE_ID": id
1595         }
1596
1597
1598 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1599
1600
1601 @test_ThingType_id
1602 def command_ttname(name):
1603     """Set TT_NAME of selected ThingType."""
1604     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1605
1606
1607 @test_ThingType_id
1608 def command_ttsymbol(char):
1609     """Set TT_SYMBOL of selected ThingType. """
1610     if 1 == len(char):
1611         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1612     else:
1613         print("Ignoring: Argument must be single character.")
1614
1615
1616 @test_ThingType_id
1617 def command_ttcorpseid(str_int):
1618     """Set TT_CORPSE_ID of selected ThingType."""
1619     val = integer_test(str_int, 0)
1620     if None != val:
1621         if val in world_db["ThingTypes"]:
1622             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1623         else:
1624             print("Ignoring: Corpse ID belongs to no known ThignType.")
1625
1626
1627 def command_taid(id_string):
1628     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1629
1630     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1631     """
1632     id = id_setter(id_string, "ThingActions", command_taid, True)
1633     if None != id:
1634         world_db["ThingActions"][id] = {
1635             "TA_EFFORT": 1,
1636             "TA_NAME": "wait"
1637         }
1638
1639
1640 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1641
1642
1643 @test_ThingAction_id
1644 def command_taname(name):
1645     """Set TA_NAME of selected ThingAction.
1646
1647     The name must match a valid thing action function. If after the name
1648     setting no ThingAction with name "wait" remains, call set_world_inactive().
1649     """
1650     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1651        or name == "pick_up":
1652         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1653         if 1 == world_db["WORLD_ACTIVE"]:
1654             wait_defined = False
1655             for id in world_db["ThingActions"]:
1656                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1657                     wait_defined = True
1658                     break
1659             if not wait_defined:
1660                 set_world_inactive()
1661     else:
1662         print("Ignoring: Invalid action name.")
1663     # In contrast to the original,naming won't map a function to a ThingAction.
1664
1665
1666 def command_ai():
1667     """Call ai() on player Thing, then turn_over()."""
1668     ai(world_db["Things"][0])
1669     turn_over()
1670
1671
1672 """Commands database.
1673
1674 Map command start tokens to ([0]) number of expected command arguments, ([1])
1675 the command's meta-ness (i.e. is it to be written to the record file, is it to
1676 be ignored in replay mode if read from server input file), and ([2]) a function
1677 to be called on it.
1678 """
1679 commands_db = {
1680     "QUIT": (0, True, command_quit),
1681     "PING": (0, True, command_ping),
1682     "THINGS_HERE": (2, True, command_thingshere),
1683     "MAKE_WORLD": (1, False, command_makeworld),
1684     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1685     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1686     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
1687     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
1688     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1689     "MAP_LENGTH": (1, False, command_maplength),
1690     "WORLD_ACTIVE": (1, False, command_worldactive),
1691     "MAP": (2, False, setter_map("MAP")),
1692     "ALTAR": (2, False, command_altar),  # #
1693     "TA_ID": (1, False, command_taid),
1694     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1695     "TA_NAME": (1, False, command_taname),
1696     "TT_ID": (1, False, command_ttid),
1697     "TT_NAME": (1, False, command_ttname),
1698     "TT_SYMBOL": (1, False, command_ttsymbol),
1699     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1700     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1701                                        0, 65535)),
1702     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1703                                          0, 255)),
1704     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1705                                         0, 255)),
1706     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1707     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
1708     "T_ID": (1, False, command_tid),
1709     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1710     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1711     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1712     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1713     "T_COMMAND": (1, False, command_tcommand),
1714     "T_TYPE": (1, False, command_ttype),
1715     "T_CARRIES": (1, False, command_tcarries),
1716     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1717     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1718     "T_MEMTHING": (3, False, command_tmemthing),
1719     "T_POSY": (1, False, setter_tpos("Y")),
1720     "T_POSX": (1, False, setter_tpos("X")),
1721     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
1722     "wait": (0, False, play_commander("wait")),
1723     "move": (1, False, play_commander("move")),
1724     "pick_up": (0, False, play_commander("pick_up")),
1725     "drop": (1, False, play_commander("drop", True)),
1726     "use": (1, False, play_commander("use", True)),
1727     "ai": (0, False, command_ai)
1728 }
1729 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1730
1731
1732 """World state database. With sane default values. (Randomness is in rand.)"""
1733 world_db = {
1734     "TURN": 0,
1735     "MAP_LENGTH": 64,
1736     "PLAYER_TYPE": 0,
1737     "WORLD_ACTIVE": 0,
1738     "GOD_MOOD": 0,  # #
1739     "GOD_FAVOR": 0,  # #
1740     "MAP": False,
1741     "ALTAR": False,
1742     "ThingActions": {},
1743     "ThingTypes": {},
1744     "Things": {}
1745 }
1746
1747 """Mapping of direction names to internal direction chars."""
1748 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1749                  "west": "s", "north-west": "w", "north-east": "e"}
1750
1751 """File IO database."""
1752 io_db = {
1753     "path_save": "save",
1754     "path_record": "record_save",
1755     "path_worldconf": "confserver/world",
1756     "path_server": "server/",
1757     "path_in": "server/in",
1758     "path_out": "server/out",
1759     "path_worldstate": "server/worldstate",
1760     "tmp_suffix": "_tmp",
1761     "kicked_by_rival": False,
1762     "worldstate_updateable": False
1763 }
1764
1765
1766 try:
1767     libpr = prep_library()
1768     rand = RandomnessIO()
1769     opts = parse_command_line_arguments()
1770     if opts.savefile:
1771         io_db["path_save"] = opts.savefile
1772         io_db["path_record"] = "record_" + opts.savefile
1773     setup_server_io()
1774     if opts.verbose:
1775         io_db["verbose"] = True
1776     if None != opts.replay:
1777         replay_game()
1778     else:
1779         play_game()
1780 except SystemExit as exit:
1781     print("ABORTING: " + exit.args[0])
1782 except:
1783     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1784     raise
1785 finally:
1786     cleanup_server_io()