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]) or # #
 677                     "_" == chr(world_db["MAP"][pos])) # #
 678         hitted = [id for id in world_db["Things"]
 679                   if world_db["Things"][id] != t
 680                   if world_db["Things"][id]["T_LIFEPOINTS"]
 681                   if world_db["Things"][id]["T_POSY"] == move_result[1]
 682                   if world_db["Things"][id]["T_POSX"] == move_result[2]]
 683         if len(hitted):
 684             hit_id = hitted[0]
 685             if t == world_db["Things"][0]:
 686                 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
 687                 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
 688                 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
 689                                                 + ".\n")
 690                 add_gods_favor(-1)  # #
 691             elif 0 == hit_id:
 692                 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 693                 strong_write(io_db["file_out"], "LOG " + hitter_name +
 694                                                 " wounds you.\n")
 695             test = decrement_lifepoints(world_db["Things"][hit_id])  # #(test=)
 696             if test and t == world_db["Things"][0]:  # #
 697                 add_gods_favor(-test)  # #
 698             return
 699     dir = [dir for dir in directions_db
 700            if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
 701     if passable:
 702         t["T_POSY"] = move_result[1]
 703         t["T_POSX"] = move_result[2]
 704         for id in t["T_CARRIES"]:
 705             world_db["Things"][id]["T_POSY"] = move_result[1]
 706             world_db["Things"][id]["T_POSX"] = move_result[2]
 707         build_fov_map(t)
 708         if t == world_db["Things"][0]:
 709             strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
 710     elif t == world_db["Things"][0]:
 711         strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
 712
 713
 714 def actor_pick_up(t):
 715     """Make t pick up (topmost?) Thing from ground into inventory."""
 716     # Topmostness is actually not defined so far. Picks most nutritious Thing.
 717     # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
 718     used_slots = len(t["T_CARRIES"]) # #
 719     if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
 720         ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
 721                if not world_db["Things"][id]["carried"]
 722                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
 723                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
 724         if len(ids):
 725             highest_id = ids[0]
 726             nutritious = 0
 727             for id in ids:
 728                 type = world_db["Things"][id]["T_TYPE"]
 729                 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
 730                     nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 731                     highest_id = id
 732             world_db["Things"][highest_id]["carried"] = True
 733             if (t != world_db["Things"][0] and  # #
 734                 world_db["Things"][highest_id]["T_PLAYERDROP"]):  # #
 735                 x = world_db["Things"][highest_id]["T_TYPE"]
 736                 score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32  # #
 737                 add_gods_favor(score)  # #
 738                 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0  # #
 739             t["T_CARRIES"].append(highest_id)
 740             if t == world_db["Things"][0]:
 741                 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
 742         elif t == world_db["Things"][0]:
 743             err = "You try to pick up an object, but there is none."
 744             strong_write(io_db["file_out"], "LOG " + err + "\n")
 745     elif t == world_db["Things"][0]: # #
 746         strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
 747                                         "No storage room to carry more.\n") # #
 748
 749
 750 def actor_drop(t):
 751     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
 752     # TODO: Handle case where T_ARGUMENT matches nothing.
 753     if len(t["T_CARRIES"]):
 754         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 755         t["T_CARRIES"].remove(id)
 756         world_db["Things"][id]["carried"] = False
 757         if t == world_db["Things"][0]:
 758             strong_write(io_db["file_out"], "LOG You drop an object.\n")
 759             world_db["Things"][id]["T_PLAYERDROP"] = 1  # #
 760     elif t == world_db["Things"][0]:
 761         err = "You try to drop an object, but you own none."
 762         strong_write(io_db["file_out"], "LOG " + err + "\n")
 763
 764
 765 def actor_use(t):
 766     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
 767     # TODO: Handle case where T_ARGUMENT matches nothing.
 768     if len(t["T_CARRIES"]):
 769         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 770         type = world_db["Things"][id]["T_TYPE"]
 771         if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
 772             t["T_CARRIES"].remove(id)
 773             del world_db["Things"][id]
 774             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 775             if t == world_db["Things"][0]:
 776                 strong_write(io_db["file_out"],
 777                              "LOG You consume this object.\n")
 778         elif t == world_db["Things"][0]:
 779             strong_write(io_db["file_out"],
 780                          "LOG You try to use this object, but fail.\n")
 781     elif t == world_db["Things"][0]:
 782         strong_write(io_db["file_out"],
 783                      "LOG You try to use an object, but you own none.\n")
 784
 785
 786 def thingproliferation(t, prol_map):
 787     """To chance of 1/TT_PROLIFERATE,create  t offspring in open neighbor cell.
 788
 789     Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
 790     marked "." in prol_map. If there are several map cell candidates, one is
 791     selected randomly.
 792     """
 793     # # 7DRL: success increments God's mood
 794     # # 7DRL: Things proliferate only on ":" ground.
 795     prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
 796     if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
 797         candidates = []
 798         for dir in [directions_db[key] for key in directions_db]:
 799             mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
 800             if mv_result[0] and ord(":") == prol_map[mv_result[1]  # #
 801             # if mv_result[0] and ord(".") == prol_map[mv_result[1]
 802                                                      * world_db["MAP_LENGTH"]
 803                                                      + mv_result[2]]:
 804                 candidates.append((mv_result[1], mv_result[2]))
 805         if len(candidates):
 806             i = rand.next() % len(candidates)
 807             id = id_setter(-1, "Things")
 808             newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
 809             world_db["Things"][id] = newT
 810             world_db["GOD_MOOD"] += 1  # #
 811
 812
 813 def try_healing(t):
 814     """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
 815
 816     On success, decrease satiation score by 32.
 817     """
 818     # # 7DRL: Successful heals increment God's mood.
 819     if t["T_SATIATION"] > 0 \
 820        and t["T_LIFEPOINTS"] < \
 821            world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
 822        and 0 == (rand.next() % 31) \
 823        and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
 824                               if world_db["ThingActions"][id]["TA_NAME"] ==
 825                                  "wait"][0]:
 826         t["T_LIFEPOINTS"] += 1
 827         world_db["GOD_MOOD"] += 1  # #
 828         t["T_SATIATION"] -= 32
 829         if t == world_db["Things"][0]:
 830             strong_write(io_db["file_out"], "LOG You heal.\n")
 831
 832
 833 def hunger(t):
 834     """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
 835     if t["T_SATIATION"] > -32768:
 836         t["T_SATIATION"] -= 1
 837     testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
 838     if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
 839         raise RuntimeError("A thing that should not hunger is hungering.")
 840     stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
 841     if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
 842         if t == world_db["Things"][0]:
 843             strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
 844         decrement_lifepoints(t)
 845
 846
 847 def get_dir_to_target(t, filter):
 848     """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
 849
 850     The path-wise nearest target is chosen, via the shortest available path.
 851     Target must not be t. On succcess, return positive value, else False.
 852     Filters:
 853     "a": Thing in FOV is below a certain distance, animate, but of ThingType
 854          that is not t's, and starts out weaker than t is; build path as
 855          avoiding things of t's ThingType
 856     "f": neighbor cell (not inhabited by any animate Thing) further away from
 857          animate Thing not further than x steps away and in FOV and of a
 858          ThingType that is not t's, and starts out stronger or as strong as t
 859          is currently; or (cornered), if no such flight cell, but Thing of
 860          above criteria is too near,1 a cell closer to it, or, if less near,
 861          just wait
 862     "c": Thing in memorized map is consumable
 863     "s": memory map cell with greatest-reachable degree of unexploredness
 864     """
 865
 866     def zero_score_map_where_char_on_memdepthmap(c):
 867         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
 868         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
 869         #           if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
 870         #     set_map_score(i, 0)
 871         map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
 872         if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
 873             raise RuntimeError("No score map allocated for "
 874                                "zero_score_map_where_char_on_memdepthmap().")
 875
 876     def set_map_score(pos, score):
 877         test = libpr.set_map_score(pos, score)
 878         if test:
 879             raise RuntimeError("No score map allocated for set_map_score().")
 880
 881     def get_map_score(pos):
 882         result = libpr.get_map_score(pos)
 883         if result < 0:
 884             raise RuntimeError("No score map allocated for get_map_score().")
 885         return result
 886
 887     def seeing_thing():
 888         if t["fovmap"] and ("a" == filter or "f" == filter):
 889             for id in world_db["Things"]:
 890                 Thing = world_db["Things"][id]
 891                 if Thing != t and Thing["T_LIFEPOINTS"] and \
 892                    t["T_TYPE"] != Thing["T_TYPE"] and \
 893                    'v' == chr(t["fovmap"][(Thing["T_POSY"]
 894                                           * world_db["MAP_LENGTH"])
 895                                           + Thing["T_POSX"]]):
 896                     ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
 897                     if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
 898                                           t["T_LIFEPOINTS"]) \
 899                        or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
 900                                              t["T_LIFEPOINTS"]):
 901                         return True
 902         elif t["T_MEMMAP"] and "c" == filter:
 903             for mt in t["T_MEMTHING"]:
 904                 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
 905                                          + mt[2]]) \
 906                    and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
 907                     return True
 908         return False
 909
 910     def set_cells_passable_on_memmap_to_65534_on_scoremap():
 911         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
 912         # ord_dot = ord(".")
 913         # memmap = t["T_MEMMAP"]
 914         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
 915         #            if ord_dot == memmap[i]]:
 916         #     set_map_score(i, 65534) # i.e. 65535-1
 917         map = c_pointer_to_bytearray(t["T_MEMMAP"])
 918         if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
 919             raise RuntimeError("No score map allocated for "
 920                         "set_cells_passable_on_memmap_to_65534_on_scoremap().")
 921
 922     def init_score_map():
 923         test = libpr.init_score_map()
 924         if test:
 925             raise RuntimeError("Malloc error in init_score_map().")
 926         ord_v = ord("v")
 927         ord_blank = ord(" ")
 928         set_cells_passable_on_memmap_to_65534_on_scoremap()
 929         if "a" == filter:
 930             for id in world_db["Things"]:
 931                 Thing = world_db["Things"][id]
 932                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
 933                       + Thing["T_POSX"]
 934                 if t != Thing and Thing["T_LIFEPOINTS"] and \
 935                    t["T_TYPE"] != Thing["T_TYPE"] and \
 936                    ord_v == t["fovmap"][pos] and \
 937                    t["T_LIFEPOINTS"] > \
 938                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
 939                     set_map_score(pos, 0)
 940                 elif t["T_TYPE"] == Thing["T_TYPE"]:
 941                     set_map_score(pos, 65535)
 942         elif "f" == filter:
 943             for id in [id for id in world_db["Things"]
 944                        if world_db["Things"][id]["T_LIFEPOINTS"]]:
 945                 Thing = world_db["Things"][id]
 946                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
 947                       + Thing["T_POSX"]
 948                 if t["T_TYPE"] != Thing["T_TYPE"] and \
 949                    ord_v == t["fovmap"][pos] and \
 950                    t["T_LIFEPOINTS"] <= \
 951                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
 952                     set_map_score(pos, 0)
 953         elif "c" == filter:
 954             for mt in [mt for mt in t["T_MEMTHING"]
 955                        if ord_blank != t["T_MEMMAP"][mt[1]
 956                                                     * world_db["MAP_LENGTH"]
 957                                                     + mt[2]]
 958                        if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
 959                 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
 960         elif "s" == filter:
 961             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
 962
 963     def rand_target_dir(neighbors, cmp, dirs):
 964         candidates = []
 965         n_candidates = 0
 966         for i in range(len(dirs)):
 967             if cmp == neighbors[i]:
 968                 candidates.append(dirs[i])
 969                 n_candidates += 1
 970         return candidates[rand.next() % n_candidates] if n_candidates else 0
 971
 972     def get_neighbor_scores(dirs, eye_pos):
 973         scores = []
 974         if libpr.ready_neighbor_scores(eye_pos):
 975             raise RuntimeError("No score map allocated for " +
 976                                "ready_neighbor_scores.()")
 977         for i in range(len(dirs)):
 978             scores.append(libpr.get_neighbor_score(i))
 979         return scores
 980
 981     def get_dir_from_neighbors():
 982         dir_to_target = False
 983         dirs = "edcxsw"
 984         eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
 985         neighbors = get_neighbor_scores(dirs, eye_pos)
 986         if "f" == filter:
 987             inhabited = [world_db["Things"][id]["T_POSY"]
 988                          * world_db["MAP_LENGTH"]
 989                          + world_db["Things"][id]["T_POSX"]
 990                          for id in world_db["Things"]
 991                          if world_db["Things"][id]["T_LIFEPOINTS"]]
 992             for i in range(len(dirs)):
 993                 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
 994                 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
 995                           + libpr.result_x()
 996                 for pos in [pos for pos in inhabited if pos == pos_cmp]:
 997                     neighbors[i] = 65535
 998                     break
 999         minmax_start = 0 if "f" == filter else 65535 - 1
1000         minmax_neighbor = minmax_start
1001         for i in range(len(dirs)):
1002             if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1003                 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1004                or ("f" != filter and minmax_neighbor > neighbors[i]):
1005                 minmax_neighbor = neighbors[i]
1006         if minmax_neighbor != minmax_start:
1007             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1008         if "f" == filter:
1009             if not dir_to_target:
1010                 if 1 == get_map_score(eye_pos):
1011                     dir_to_target = rand_target_dir(neighbors, 0, dirs)
1012                 elif 3 >= get_map_score(eye_pos):
1013                     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1014                                       if
1015                                       world_db["ThingActions"][id]["TA_NAME"]
1016                                          == "wait"][0]
1017                     return 1
1018             elif dir_to_target and 3 < get_map_score(eye_pos):
1019                 dir_to_target = 0
1020         elif "a" == filter and 10 <= get_map_score(eye_pos):
1021             dir_to_target = 0
1022         return dir_to_target
1023
1024     dir_to_target = False
1025     mem_depth_c = b' '
1026     run_i = 9 + 1 if "s" == filter else 1
1027     while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1028         run_i -= 1
1029         init_score_map()
1030         mem_depth_c = b'9' if b' ' == mem_depth_c \
1031                            else bytes([mem_depth_c[0] - 1])
1032         if libpr.dijkstra_map():
1033             raise RuntimeError("No score map allocated for dijkstra_map().")
1034         dir_to_target = get_dir_from_neighbors()
1035         libpr.free_score_map()
1036         if dir_to_target and str == type(dir_to_target):
1037             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1038                               if world_db["ThingActions"][id]["TA_NAME"]
1039                                  == "move"][0]
1040             t["T_ARGUMENT"] = ord(dir_to_target)
1041     return dir_to_target
1042
1043
1044 def standing_on_consumable(t):
1045     """Return True/False whether t is standing on a consumable."""
1046     for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1047                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1048                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1049                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1050                           ["TT_CONSUMABLE"]]:
1051         return True
1052     return False
1053
1054
1055 def get_inventory_slot_to_consume(t):
1056     """Return slot Id of strongest consumable in t's inventory, else -1."""
1057     cmp_consumability = 0
1058     selection = -1
1059     i = 0
1060     for id in t["T_CARRIES"]:
1061         type = world_db["Things"][id]["T_TYPE"]
1062         if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
1063             cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1064             selection = i
1065         i += 1
1066     return selection
1067
1068
1069 def ai(t):
1070     """Determine next command/argment for actor t via AI algorithms.
1071
1072     AI will look for, and move towards, enemies (animate Things not of their
1073     own ThingType); if they see none, they will consume consumables in their
1074     inventory; if there are none, they will pick up what they stand on if they
1075     stand on consumables; if they stand on none, they will move towards the
1076     next consumable they see or remember on the map; if they see or remember
1077     none, they will explore parts of the map unseen since ever or for at least
1078     one turn; if there is nothing to explore, they will simply wait.
1079     """
1080     # # 7DRL add: Don't pick up or search things when inventory is full.
1081     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1082                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1083     if not get_dir_to_target(t, "f"):
1084         sel = get_inventory_slot_to_consume(t)
1085         if -1 != sel:
1086             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1087                               if world_db["ThingActions"][id]["TA_NAME"]
1088                                  == "use"][0]
1089             t["T_ARGUMENT"] = sel
1090         elif standing_on_consumable(t) \
1091              and (len(t["T_CARRIES"]) < # #
1092                  world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1093             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1094                               if world_db["ThingActions"][id]["TA_NAME"]
1095                                  == "pick_up"][0]
1096         elif (not
1097               (len(t["T_CARRIES"]) < # #
1098                 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1099                and get_dir_to_target(t, "c"))) and \
1100              (not get_dir_to_target(t, "a")):
1101             get_dir_to_target(t, "s")
1102
1103
1104 def turn_over():
1105     """Run game world and its inhabitants until new player input expected."""
1106     id = 0
1107     whilebreaker = False
1108     while world_db["Things"][0]["T_LIFEPOINTS"]:
1109         proliferable_map = world_db["MAP"][:]
1110         for id in [id for id in world_db["Things"]
1111                    if not world_db["Things"][id]["carried"]]:
1112             y = world_db["Things"][id]["T_POSY"]
1113             x = world_db["Things"][id]["T_POSX"]
1114             proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1115         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1116             if not id in world_db["Things"] or \
1117                world_db["Things"][id]["carried"]:   # May have been consumed or
1118                 continue                            # picked up during turn …
1119             Thing = world_db["Things"][id]
1120             if Thing["T_LIFEPOINTS"]:
1121                 if not Thing["T_COMMAND"]:
1122                     update_map_memory(Thing)
1123                     if 0 == id:
1124                         whilebreaker = True
1125                         break
1126                     ai(Thing)
1127                 try_healing(Thing)
1128                 Thing["T_PROGRESS"] += 1
1129                 taid = [a for a in world_db["ThingActions"]
1130                           if a == Thing["T_COMMAND"]][0]
1131                 ThingAction = world_db["ThingActions"][taid]
1132                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1133                     eval("actor_" + ThingAction["TA_NAME"])(Thing)
1134                     Thing["T_COMMAND"] = 0
1135                     Thing["T_PROGRESS"] = 0
1136                 hunger(Thing)
1137             thingproliferation(Thing, proliferable_map)
1138         if whilebreaker:
1139             break
1140         world_db["TURN"] += 1
1141
1142
1143 def new_Thing(type, pos=(0, 0)):
1144     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1145     thing = {
1146         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1147         "T_ARGUMENT": 0,
1148         "T_PROGRESS": 0,
1149         "T_SATIATION": 0,
1150         "T_COMMAND": 0,
1151         "T_PLAYERDROP": 0,  # #
1152         "T_TYPE": type,
1153         "T_POSY": pos[0],
1154         "T_POSX": pos[1],
1155         "T_CARRIES": [],
1156         "carried": False,
1157         "T_MEMTHING": [],
1158         "T_MEMMAP": False,
1159         "T_MEMDEPTHMAP": False,
1160         "fovmap": False
1161     }
1162     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1163         build_fov_map(thing)
1164     return thing
1165
1166
1167 def id_setter(id, category, id_store=False, start_at_1=False):
1168     """Set ID of object of category to manipulate ID unused? Create new one.
1169
1170     The ID is stored as id_store.id (if id_store is set). If the integer of the
1171     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1172     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1173     always returned when no new object is created, otherwise the new object's
1174     ID.
1175     """
1176     min = 0 if start_at_1 else -1
1177     if str == type(id):
1178         id = integer_test(id, min)
1179     if None != id:
1180         if id in world_db[category]:
1181             if id_store:
1182                 id_store.id = id
1183             return None
1184         else:
1185             if (start_at_1 and 0 == id) \
1186                or ((not start_at_1) and (id < 0)):
1187                 id = 0 if start_at_1 else -1
1188                 while 1:
1189                     id = id + 1
1190                     if id not in world_db[category]:
1191                         break
1192             if id_store:
1193                 id_store.id = id
1194     return id
1195
1196
1197 def command_ping():
1198     """Send PONG line to server output file."""
1199     strong_write(io_db["file_out"], "PONG\n")
1200
1201
1202 def command_quit():
1203     """Abort server process."""
1204     if None == opts.replay:
1205         if world_db["WORLD_ACTIVE"]:
1206             save_world()
1207         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1208     raise SystemExit("received QUIT command")
1209
1210
1211 def command_thingshere(str_y, str_x):
1212     """Write to out file list of Things known to player at coordinate y, x."""
1213     if world_db["WORLD_ACTIVE"]:
1214         y = integer_test(str_y, 0, 255)
1215         x = integer_test(str_x, 0, 255)
1216         length = world_db["MAP_LENGTH"]
1217         if None != y and None != x and y < length and x < length:
1218             pos = (y * world_db["MAP_LENGTH"]) + x
1219             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1220             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1221                 for id in world_db["Things"]:
1222                     if y == world_db["Things"][id]["T_POSY"] \
1223                        and x == world_db["Things"][id]["T_POSX"] \
1224                        and not world_db["Things"][id]["carried"]:
1225                         type = world_db["Things"][id]["T_TYPE"]
1226                         name = world_db["ThingTypes"][type]["TT_NAME"]
1227                         strong_write(io_db["file_out"], name + "\n")
1228             else:
1229                 for mt in world_db["Things"][0]["T_MEMTHING"]:
1230                     if y == mt[1] and x == mt[2]:
1231                         name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1232                         strong_write(io_db["file_out"], name + "\n")
1233             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1234         else:
1235             print("Ignoring: Invalid map coordinates.")
1236     else:
1237         print("Ignoring: Command only works on existing worlds.")
1238
1239
1240 def play_commander(action, args=False):
1241     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1242
1243     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1244     """
1245
1246     def set_command():
1247         id = [x for x in world_db["ThingActions"]
1248                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1249         world_db["Things"][0]["T_COMMAND"] = id
1250         turn_over()
1251
1252     def set_command_and_argument_int(str_arg):
1253         val = integer_test(str_arg, 0, 255)
1254         if None != val:
1255             world_db["Things"][0]["T_ARGUMENT"] = val
1256             set_command()
1257
1258     def set_command_and_argument_movestring(str_arg):
1259         if str_arg in directions_db:
1260             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1261             set_command()
1262         else:
1263             print("Ignoring: Argument must be valid direction string.")
1264
1265     if action == "move":
1266         return set_command_and_argument_movestring
1267     elif args:
1268         return set_command_and_argument_int
1269     else:
1270         return set_command
1271
1272
1273 def command_seedrandomness(seed_string):
1274     """Set rand seed to int(seed_string)."""
1275     val = integer_test(seed_string, 0, 4294967295)
1276     if None != val:
1277         rand.seed = val
1278
1279
1280 def command_makeworld(seed_string):
1281     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1282
1283     Seed rand with seed. Do more only with a "wait" ThingAction and
1284     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1285     world_db["Things"] emptied, call make_map() and set
1286     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1287     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1288     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1289     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1290     """
1291
1292     # def free_pos(plant=False):
1293     def free_pos(plant=False):  # #
1294         i = 0
1295         while 1:
1296             err = "Space to put thing on too hard to find. Map too small?"
1297             while 1:
1298                 y = rand.next() % world_db["MAP_LENGTH"]
1299                 x = rand.next() % world_db["MAP_LENGTH"]
1300                 pos = y * world_db["MAP_LENGTH"] + x;
1301                 if (not plant  # #
1302                     and "." == chr(world_db["MAP"][pos])) \
1303                    or ":" == chr(world_db["MAP"][pos]):  # #
1304                     break
1305                 i += 1
1306                 if i == 65535:
1307                     raise SystemExit(err)
1308             # Replica of C code, wrongly ignores animatedness of new Thing.
1309             pos_clear = (0 == len([id for id in world_db["Things"]
1310                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1311                                    if world_db["Things"][id]["T_POSY"] == y
1312                                    if world_db["Things"][id]["T_POSX"] == x]))
1313             if pos_clear:
1314                 break
1315         return (y, x)
1316
1317     val = integer_test(seed_string, 0, 4294967295)
1318     if None == val:
1319         return
1320     rand.seed = val
1321     player_will_be_generated = False
1322     playertype = world_db["PLAYER_TYPE"]
1323     for ThingType in world_db["ThingTypes"]:
1324         if playertype == ThingType:
1325             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1326                 player_will_be_generated = True
1327             break
1328     if not player_will_be_generated:
1329         print("Ignoring: No player type with start number >0 defined.")
1330         return
1331     wait_action = False
1332     for ThingAction in world_db["ThingActions"]:
1333         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1334             wait_action = True
1335     if not wait_action:
1336         print("Ignoring: No thing action with name 'wait' defined.")
1337         return
1338     world_db["Things"] = {}
1339     make_map()
1340     world_db["ALTAR"] = free_pos()  # #
1341     world_db["MAP"][world_db["ALTAR"][0] * world_db["MAP_LENGTH"]  # #
1342                     + world_db["ALTAR"][1]] = ord("_")  # #
1343     world_db["WORLD_ACTIVE"] = 1
1344     world_db["TURN"] = 1
1345     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1346         id = id_setter(-1, "Things")
1347         world_db["Things"][id] = new_Thing(playertype, free_pos())
1348     if not world_db["Things"][0]["fovmap"]:
1349         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1350         world_db["Things"][0]["fovmap"] = empty_fovmap
1351     update_map_memory(world_db["Things"][0])
1352     for type in world_db["ThingTypes"]:
1353         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1354             if type != playertype:
1355                 id = id_setter(-1, "Things")
1356                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1357                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1358     strong_write(io_db["file_out"], "NEW_WORLD\n")
1359
1360
1361 def command_altar(str_y, str_x):  # #
1362     """Set position of Island God's altar."""
1363     y = integer_test(str_y, 0, 255)
1364     x = integer_test(str_x, 0, 255)
1365     if None != y and None != x:
1366         if y < world_db["MAP_LENGTH"] and x < world_db["MAP_LENGTH"]:
1367             world_db["ALTAR"] = (y, x)
1368             world_db["MAP"][y * world_db["MAP_LENGTH"] + x] = ord("_")
1369         else:
1370             print("Ignoring: Position is outside of map.")
1371
1372
1373 def command_maplength(maplength_string):
1374     """Redefine map length. Invalidate map, therefore lose all things on it."""
1375     val = integer_test(maplength_string, 1, 256)
1376     if None != val:
1377         world_db["MAP_LENGTH"] = val
1378         world_db["MAP"] = False
1379         set_world_inactive()
1380         world_db["Things"] = {}
1381         libpr.set_maplength(val)
1382
1383
1384 def command_worldactive(worldactive_string):
1385     """Toggle world_db["WORLD_ACTIVE"] if possible.
1386
1387     An active world can always be set inactive. An inactive world can only be
1388     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1389     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1390     """
1391     # 7DRL: Altar position must also be set for world activation.
1392     val = integer_test(worldactive_string, 0, 1)
1393     if None != val:
1394         if 0 != world_db["WORLD_ACTIVE"]:
1395             if 0 == val:
1396                 set_world_inactive()
1397             else:
1398                 print("World already active.")
1399         elif 0 == world_db["WORLD_ACTIVE"]:
1400             wait_exists = False
1401             for ThingAction in world_db["ThingActions"]:
1402                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1403                     wait_exists = True
1404                     break
1405             player_exists = False
1406             for Thing in world_db["Things"]:
1407                 if 0 == Thing:
1408                     player_exists = True
1409                     break
1410             if wait_exists and player_exists and world_db["MAP"] \
1411                 and  world_db["ALTAR"]:  # #
1412                 for id in world_db["Things"]:
1413                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1414                         build_fov_map(world_db["Things"][id])
1415                         if 0 == id:
1416                             update_map_memory(world_db["Things"][id], False)
1417                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1418                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1419                     world_db["Things"][0]["fovmap"] = empty_fovmap
1420                 world_db["WORLD_ACTIVE"] = 1
1421             else:
1422                 print("Ignoring: Not all conditions for world activation met.")
1423
1424
1425 def test_for_id_maker(object, category):
1426     """Return decorator testing for object having "id" attribute."""
1427     def decorator(f):
1428         def helper(*args):
1429             if hasattr(object, "id"):
1430                 f(*args)
1431             else:
1432                 print("Ignoring: No " + category +
1433                       " defined to manipulate yet.")
1434         return helper
1435     return decorator
1436
1437
1438 def command_tid(id_string):
1439     """Set ID of Thing to manipulate. ID unused? Create new one.
1440
1441     Default new Thing's type to the first available ThingType, others: zero.
1442     """
1443     id = id_setter(id_string, "Things", command_tid)
1444     if None != id:
1445         if world_db["ThingTypes"] == {}:
1446             print("Ignoring: No ThingType to settle new Thing in.")
1447             return
1448         type = list(world_db["ThingTypes"].keys())[0]
1449         world_db["Things"][id] = new_Thing(type)
1450
1451
1452 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1453
1454
1455 @test_Thing_id
1456 def command_tcommand(str_int):
1457     """Set T_COMMAND of selected Thing."""
1458     val = integer_test(str_int, 0)
1459     if None != val:
1460         if 0 == val or val in world_db["ThingActions"]:
1461             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1462         else:
1463             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1464
1465
1466 @test_Thing_id
1467 def command_ttype(str_int):
1468     """Set T_TYPE of selected Thing."""
1469     val = integer_test(str_int, 0)
1470     if None != val:
1471         if val in world_db["ThingTypes"]:
1472             world_db["Things"][command_tid.id]["T_TYPE"] = val
1473         else:
1474             print("Ignoring: ThingType ID belongs to no known ThingType.")
1475
1476
1477 @test_Thing_id
1478 def command_tcarries(str_int):
1479     """Append int(str_int) to T_CARRIES of selected Thing.
1480
1481     The ID int(str_int) must not be of the selected Thing, and must belong to a
1482     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1483     """
1484     val = integer_test(str_int, 0)
1485     if None != val:
1486         if val == command_tid.id:
1487             print("Ignoring: Thing cannot carry itself.")
1488         elif val in world_db["Things"] \
1489              and not world_db["Things"][val]["carried"]:
1490             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1491             world_db["Things"][val]["carried"] = True
1492         else:
1493             print("Ignoring: Thing not available for carrying.")
1494     # Note that the whole carrying structure is different from the C version:
1495     # Carried-ness is marked by a "carried" flag, not by Things containing
1496     # Things internally.
1497
1498
1499 @test_Thing_id
1500 def command_tmemthing(str_t, str_y, str_x):
1501     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1502
1503     The type must fit to an existing ThingType, and the position into the map.
1504     """
1505     type = integer_test(str_t, 0)
1506     posy = integer_test(str_y, 0, 255)
1507     posx = integer_test(str_x, 0, 255)
1508     if None != type and None != posy and None != posx:
1509         if type not in world_db["ThingTypes"] \
1510            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1511             print("Ignoring: Illegal value for thing type or position.")
1512         else:
1513             memthing = (type, posy, posx)
1514             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1515
1516
1517 def setter_map(maptype):
1518     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1519
1520     If no map of maptype exists yet, initialize it with ' ' bytes first.
1521     """
1522
1523     def valid_map_line(str_int, mapline):
1524         val = integer_test(str_int, 0, 255)
1525         if None != val:
1526             if val >= world_db["MAP_LENGTH"]:
1527                 print("Illegal value for map line number.")
1528             elif len(mapline) != world_db["MAP_LENGTH"]:
1529                 print("Map line length is unequal map width.")
1530             else:
1531                 return val
1532         return None
1533
1534     def nonThingMap_helper(str_int, mapline):
1535         val = valid_map_line(str_int, mapline)
1536         if None != val:
1537             length = world_db["MAP_LENGTH"]
1538             if not world_db["MAP"]:
1539                 map = bytearray(b' ' * (length ** 2))
1540             else:
1541                 map = world_db["MAP"]
1542             map[val * length:(val * length) + length] = mapline.encode()
1543             if not world_db["MAP"]:
1544                 world_db["MAP"] = map
1545
1546     @test_Thing_id
1547     def ThingMap_helper(str_int, mapline):
1548         val = valid_map_line(str_int, mapline)
1549         if None != val:
1550             length = world_db["MAP_LENGTH"]
1551             if not world_db["Things"][command_tid.id][maptype]:
1552                 map = bytearray(b' ' * (length ** 2))
1553             else:
1554                 map = world_db["Things"][command_tid.id][maptype]
1555             map[val * length:(val * length) + length] = mapline.encode()
1556             if not world_db["Things"][command_tid.id][maptype]:
1557                 world_db["Things"][command_tid.id][maptype] = map
1558
1559     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1560
1561
1562 def setter_tpos(axis):
1563     """Generate setter for T_POSX or  T_POSY of selected Thing.
1564
1565     If world is active, rebuilds animate things' fovmap, player's memory map.
1566     """
1567     @test_Thing_id
1568     def helper(str_int):
1569         val = integer_test(str_int, 0, 255)
1570         if None != val:
1571             if val < world_db["MAP_LENGTH"]:
1572                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1573                 if world_db["WORLD_ACTIVE"] \
1574                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1575                     build_fov_map(world_db["Things"][command_tid.id])
1576                     if 0 == command_tid.id:
1577                         update_map_memory(world_db["Things"][command_tid.id])
1578             else:
1579                 print("Ignoring: Position is outside of map.")
1580     return helper
1581
1582
1583 def command_ttid(id_string):
1584     """Set ID of ThingType to manipulate. ID unused? Create new one.
1585
1586     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1587     """
1588     id = id_setter(id_string, "ThingTypes", command_ttid)
1589     if None != id:
1590         world_db["ThingTypes"][id] = {
1591             "TT_NAME": "(none)",
1592             "TT_CONSUMABLE": 0,
1593             "TT_LIFEPOINTS": 0,
1594             "TT_PROLIFERATE": 0,
1595             "TT_START_NUMBER": 0,
1596             "TT_STORAGE": 0, # #
1597             "TT_SYMBOL": "?",
1598             "TT_CORPSE_ID": id
1599         }
1600
1601
1602 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1603
1604
1605 @test_ThingType_id
1606 def command_ttname(name):
1607     """Set TT_NAME of selected ThingType."""
1608     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1609
1610
1611 @test_ThingType_id
1612 def command_ttsymbol(char):
1613     """Set TT_SYMBOL of selected ThingType. """
1614     if 1 == len(char):
1615         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1616     else:
1617         print("Ignoring: Argument must be single character.")
1618
1619
1620 @test_ThingType_id
1621 def command_ttcorpseid(str_int):
1622     """Set TT_CORPSE_ID of selected ThingType."""
1623     val = integer_test(str_int, 0)
1624     if None != val:
1625         if val in world_db["ThingTypes"]:
1626             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1627         else:
1628             print("Ignoring: Corpse ID belongs to no known ThignType.")
1629
1630
1631 def command_taid(id_string):
1632     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1633
1634     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1635     """
1636     id = id_setter(id_string, "ThingActions", command_taid, True)
1637     if None != id:
1638         world_db["ThingActions"][id] = {
1639             "TA_EFFORT": 1,
1640             "TA_NAME": "wait"
1641         }
1642
1643
1644 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1645
1646
1647 @test_ThingAction_id
1648 def command_taname(name):
1649     """Set TA_NAME of selected ThingAction.
1650
1651     The name must match a valid thing action function. If after the name
1652     setting no ThingAction with name "wait" remains, call set_world_inactive().
1653     """
1654     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1655        or name == "pick_up":
1656         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1657         if 1 == world_db["WORLD_ACTIVE"]:
1658             wait_defined = False
1659             for id in world_db["ThingActions"]:
1660                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1661                     wait_defined = True
1662                     break
1663             if not wait_defined:
1664                 set_world_inactive()
1665     else:
1666         print("Ignoring: Invalid action name.")
1667     # In contrast to the original,naming won't map a function to a ThingAction.
1668
1669
1670 def command_ai():
1671     """Call ai() on player Thing, then turn_over()."""
1672     ai(world_db["Things"][0])
1673     turn_over()
1674
1675
1676 """Commands database.
1677
1678 Map command start tokens to ([0]) number of expected command arguments, ([1])
1679 the command's meta-ness (i.e. is it to be written to the record file, is it to
1680 be ignored in replay mode if read from server input file), and ([2]) a function
1681 to be called on it.
1682 """
1683 commands_db = {
1684     "QUIT": (0, True, command_quit),
1685     "PING": (0, True, command_ping),
1686     "THINGS_HERE": (2, True, command_thingshere),
1687     "MAKE_WORLD": (1, False, command_makeworld),
1688     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1689     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1690     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
1691     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
1692     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1693     "MAP_LENGTH": (1, False, command_maplength),
1694     "WORLD_ACTIVE": (1, False, command_worldactive),
1695     "MAP": (2, False, setter_map("MAP")),
1696     "ALTAR": (2, False, command_altar),  # #
1697     "TA_ID": (1, False, command_taid),
1698     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1699     "TA_NAME": (1, False, command_taname),
1700     "TT_ID": (1, False, command_ttid),
1701     "TT_NAME": (1, False, command_ttname),
1702     "TT_SYMBOL": (1, False, command_ttsymbol),
1703     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1704     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1705                                        0, 65535)),
1706     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1707                                          0, 255)),
1708     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1709                                         0, 255)),
1710     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1711     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
1712     "T_ID": (1, False, command_tid),
1713     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1714     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1715     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1716     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1717     "T_COMMAND": (1, False, command_tcommand),
1718     "T_TYPE": (1, False, command_ttype),
1719     "T_CARRIES": (1, False, command_tcarries),
1720     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1721     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1722     "T_MEMTHING": (3, False, command_tmemthing),
1723     "T_POSY": (1, False, setter_tpos("Y")),
1724     "T_POSX": (1, False, setter_tpos("X")),
1725     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
1726     "wait": (0, False, play_commander("wait")),
1727     "move": (1, False, play_commander("move")),
1728     "pick_up": (0, False, play_commander("pick_up")),
1729     "drop": (1, False, play_commander("drop", True)),
1730     "use": (1, False, play_commander("use", True)),
1731     "ai": (0, False, command_ai)
1732 }
1733 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1734
1735
1736 """World state database. With sane default values. (Randomness is in rand.)"""
1737 world_db = {
1738     "TURN": 0,
1739     "MAP_LENGTH": 64,
1740     "PLAYER_TYPE": 0,
1741     "WORLD_ACTIVE": 0,
1742     "GOD_MOOD": 0,  # #
1743     "GOD_FAVOR": 0,  # #
1744     "MAP": False,
1745     "ALTAR": False,
1746     "ThingActions": {},
1747     "ThingTypes": {},
1748     "Things": {}
1749 }
1750
1751 """Mapping of direction names to internal direction chars."""
1752 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1753                  "west": "s", "north-west": "w", "north-east": "e"}
1754
1755 """File IO database."""
1756 io_db = {
1757     "path_save": "save",
1758     "path_record": "record_save",
1759     "path_worldconf": "confserver/world",
1760     "path_server": "server/",
1761     "path_in": "server/in",
1762     "path_out": "server/out",
1763     "path_worldstate": "server/worldstate",
1764     "tmp_suffix": "_tmp",
1765     "kicked_by_rival": False,
1766     "worldstate_updateable": False
1767 }
1768
1769
1770 try:
1771     libpr = prep_library()
1772     rand = RandomnessIO()
1773     opts = parse_command_line_arguments()
1774     if opts.savefile:
1775         io_db["path_save"] = opts.savefile
1776         io_db["path_record"] = "record_" + opts.savefile
1777     setup_server_io()
1778     if opts.verbose:
1779         io_db["verbose"] = True
1780     if None != opts.replay:
1781         replay_game()
1782     else:
1783         play_game()
1784 except SystemExit as exit:
1785     print("ABORTING: " + exit.args[0])
1786 except:
1787     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1788     raise
1789 finally:
1790     cleanup_server_io()