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                 hunger(Thing)
1129                 if Thing["T_LIFEPOINTS"]:
1130                     Thing["T_PROGRESS"] += 1
1131                     taid = [a for a in world_db["ThingActions"]
1132                               if a == Thing["T_COMMAND"]][0]
1133                     ThingAction = world_db["ThingActions"][taid]
1134                     if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1135                         eval("actor_" + ThingAction["TA_NAME"])(Thing)
1136                         Thing["T_COMMAND"] = 0
1137                         Thing["T_PROGRESS"] = 0
1138             thingproliferation(Thing, proliferable_map)
1139         if whilebreaker:
1140             break
1141         world_db["TURN"] += 1
1142
1143
1144 def new_Thing(type, pos=(0, 0)):
1145     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1146     thing = {
1147         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1148         "T_ARGUMENT": 0,
1149         "T_PROGRESS": 0,
1150         "T_SATIATION": 0,
1151         "T_COMMAND": 0,
1152         "T_PLAYERDROP": 0,  # #
1153         "T_TYPE": type,
1154         "T_POSY": pos[0],
1155         "T_POSX": pos[1],
1156         "T_CARRIES": [],
1157         "carried": False,
1158         "T_MEMTHING": [],
1159         "T_MEMMAP": False,
1160         "T_MEMDEPTHMAP": False,
1161         "fovmap": False
1162     }
1163     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1164         build_fov_map(thing)
1165     return thing
1166
1167
1168 def id_setter(id, category, id_store=False, start_at_1=False):
1169     """Set ID of object of category to manipulate ID unused? Create new one.
1170
1171     The ID is stored as id_store.id (if id_store is set). If the integer of the
1172     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1173     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1174     always returned when no new object is created, otherwise the new object's
1175     ID.
1176     """
1177     min = 0 if start_at_1 else -1
1178     if str == type(id):
1179         id = integer_test(id, min)
1180     if None != id:
1181         if id in world_db[category]:
1182             if id_store:
1183                 id_store.id = id
1184             return None
1185         else:
1186             if (start_at_1 and 0 == id) \
1187                or ((not start_at_1) and (id < 0)):
1188                 id = 0 if start_at_1 else -1
1189                 while 1:
1190                     id = id + 1
1191                     if id not in world_db[category]:
1192                         break
1193             if id_store:
1194                 id_store.id = id
1195     return id
1196
1197
1198 def command_ping():
1199     """Send PONG line to server output file."""
1200     strong_write(io_db["file_out"], "PONG\n")
1201
1202
1203 def command_quit():
1204     """Abort server process."""
1205     if None == opts.replay:
1206         if world_db["WORLD_ACTIVE"]:
1207             save_world()
1208         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1209     raise SystemExit("received QUIT command")
1210
1211
1212 def command_thingshere(str_y, str_x):
1213     """Write to out file list of Things known to player at coordinate y, x."""
1214     if world_db["WORLD_ACTIVE"]:
1215         y = integer_test(str_y, 0, 255)
1216         x = integer_test(str_x, 0, 255)
1217         length = world_db["MAP_LENGTH"]
1218         if None != y and None != x and y < length and x < length:
1219             pos = (y * world_db["MAP_LENGTH"]) + x
1220             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1221             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1222                 for id in world_db["Things"]:
1223                     if y == world_db["Things"][id]["T_POSY"] \
1224                        and x == world_db["Things"][id]["T_POSX"] \
1225                        and not world_db["Things"][id]["carried"]:
1226                         type = world_db["Things"][id]["T_TYPE"]
1227                         name = world_db["ThingTypes"][type]["TT_NAME"]
1228                         strong_write(io_db["file_out"], name + "\n")
1229             else:
1230                 for mt in world_db["Things"][0]["T_MEMTHING"]:
1231                     if y == mt[1] and x == mt[2]:
1232                         name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1233                         strong_write(io_db["file_out"], name + "\n")
1234             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1235         else:
1236             print("Ignoring: Invalid map coordinates.")
1237     else:
1238         print("Ignoring: Command only works on existing worlds.")
1239
1240
1241 def play_commander(action, args=False):
1242     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1243
1244     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1245     """
1246
1247     def set_command():
1248         id = [x for x in world_db["ThingActions"]
1249                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1250         world_db["Things"][0]["T_COMMAND"] = id
1251         turn_over()
1252
1253     def set_command_and_argument_int(str_arg):
1254         val = integer_test(str_arg, 0, 255)
1255         if None != val:
1256             world_db["Things"][0]["T_ARGUMENT"] = val
1257             set_command()
1258
1259     def set_command_and_argument_movestring(str_arg):
1260         if str_arg in directions_db:
1261             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1262             set_command()
1263         else:
1264             print("Ignoring: Argument must be valid direction string.")
1265
1266     if action == "move":
1267         return set_command_and_argument_movestring
1268     elif args:
1269         return set_command_and_argument_int
1270     else:
1271         return set_command
1272
1273
1274 def command_seedrandomness(seed_string):
1275     """Set rand seed to int(seed_string)."""
1276     val = integer_test(seed_string, 0, 4294967295)
1277     if None != val:
1278         rand.seed = val
1279
1280
1281 def command_makeworld(seed_string):
1282     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1283
1284     Seed rand with seed. Do more only with a "wait" ThingAction and
1285     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1286     world_db["Things"] emptied, call make_map() and set
1287     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1288     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1289     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1290     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1291     """
1292
1293     # def free_pos(plant=False):
1294     def free_pos(plant=False):  # #
1295         i = 0
1296         while 1:
1297             err = "Space to put thing on too hard to find. Map too small?"
1298             while 1:
1299                 y = rand.next() % world_db["MAP_LENGTH"]
1300                 x = rand.next() % world_db["MAP_LENGTH"]
1301                 pos = y * world_db["MAP_LENGTH"] + x;
1302                 if (not plant  # #
1303                     and "." == chr(world_db["MAP"][pos])) \
1304                    or ":" == chr(world_db["MAP"][pos]):  # #
1305                     break
1306                 i += 1
1307                 if i == 65535:
1308                     raise SystemExit(err)
1309             # Replica of C code, wrongly ignores animatedness of new Thing.
1310             pos_clear = (0 == len([id for id in world_db["Things"]
1311                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1312                                    if world_db["Things"][id]["T_POSY"] == y
1313                                    if world_db["Things"][id]["T_POSX"] == x]))
1314             if pos_clear:
1315                 break
1316         return (y, x)
1317
1318     val = integer_test(seed_string, 0, 4294967295)
1319     if None == val:
1320         return
1321     rand.seed = val
1322     player_will_be_generated = False
1323     playertype = world_db["PLAYER_TYPE"]
1324     for ThingType in world_db["ThingTypes"]:
1325         if playertype == ThingType:
1326             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1327                 player_will_be_generated = True
1328             break
1329     if not player_will_be_generated:
1330         print("Ignoring: No player type with start number >0 defined.")
1331         return
1332     wait_action = False
1333     for ThingAction in world_db["ThingActions"]:
1334         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1335             wait_action = True
1336     if not wait_action:
1337         print("Ignoring: No thing action with name 'wait' defined.")
1338         return
1339     world_db["Things"] = {}
1340     make_map()
1341     world_db["ALTAR"] = free_pos()  # #
1342     world_db["MAP"][world_db["ALTAR"][0] * world_db["MAP_LENGTH"]  # #
1343                     + world_db["ALTAR"][1]] = ord("_")  # #
1344     world_db["WORLD_ACTIVE"] = 1
1345     world_db["TURN"] = 1
1346     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1347         id = id_setter(-1, "Things")
1348         world_db["Things"][id] = new_Thing(playertype, free_pos())
1349     if not world_db["Things"][0]["fovmap"]:
1350         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1351         world_db["Things"][0]["fovmap"] = empty_fovmap
1352     update_map_memory(world_db["Things"][0])
1353     for type in world_db["ThingTypes"]:
1354         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1355             if type != playertype:
1356                 id = id_setter(-1, "Things")
1357                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1358                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1359     strong_write(io_db["file_out"], "NEW_WORLD\n")
1360
1361
1362 def command_altar(str_y, str_x):  # #
1363     """Set position of Island God's altar."""
1364     y = integer_test(str_y, 0, 255)
1365     x = integer_test(str_x, 0, 255)
1366     if None != y and None != x:
1367         if y < world_db["MAP_LENGTH"] and x < world_db["MAP_LENGTH"]:
1368             world_db["ALTAR"] = (y, x)
1369             world_db["MAP"][y * world_db["MAP_LENGTH"] + x] = ord("_")
1370         else:
1371             print("Ignoring: Position is outside of map.")
1372
1373
1374 def command_maplength(maplength_string):
1375     """Redefine map length. Invalidate map, therefore lose all things on it."""
1376     val = integer_test(maplength_string, 1, 256)
1377     if None != val:
1378         world_db["MAP_LENGTH"] = val
1379         world_db["MAP"] = False
1380         set_world_inactive()
1381         world_db["Things"] = {}
1382         libpr.set_maplength(val)
1383
1384
1385 def command_worldactive(worldactive_string):
1386     """Toggle world_db["WORLD_ACTIVE"] if possible.
1387
1388     An active world can always be set inactive. An inactive world can only be
1389     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1390     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1391     """
1392     # 7DRL: Altar position must also be set for world activation.
1393     val = integer_test(worldactive_string, 0, 1)
1394     if None != val:
1395         if 0 != world_db["WORLD_ACTIVE"]:
1396             if 0 == val:
1397                 set_world_inactive()
1398             else:
1399                 print("World already active.")
1400         elif 0 == world_db["WORLD_ACTIVE"]:
1401             wait_exists = False
1402             for ThingAction in world_db["ThingActions"]:
1403                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1404                     wait_exists = True
1405                     break
1406             player_exists = False
1407             for Thing in world_db["Things"]:
1408                 if 0 == Thing:
1409                     player_exists = True
1410                     break
1411             if wait_exists and player_exists and world_db["MAP"] \
1412                 and  world_db["ALTAR"]:  # #
1413                 for id in world_db["Things"]:
1414                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1415                         build_fov_map(world_db["Things"][id])
1416                         if 0 == id:
1417                             update_map_memory(world_db["Things"][id], False)
1418                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1419                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1420                     world_db["Things"][0]["fovmap"] = empty_fovmap
1421                 world_db["WORLD_ACTIVE"] = 1
1422             else:
1423                 print("Ignoring: Not all conditions for world activation met.")
1424
1425
1426 def test_for_id_maker(object, category):
1427     """Return decorator testing for object having "id" attribute."""
1428     def decorator(f):
1429         def helper(*args):
1430             if hasattr(object, "id"):
1431                 f(*args)
1432             else:
1433                 print("Ignoring: No " + category +
1434                       " defined to manipulate yet.")
1435         return helper
1436     return decorator
1437
1438
1439 def command_tid(id_string):
1440     """Set ID of Thing to manipulate. ID unused? Create new one.
1441
1442     Default new Thing's type to the first available ThingType, others: zero.
1443     """
1444     id = id_setter(id_string, "Things", command_tid)
1445     if None != id:
1446         if world_db["ThingTypes"] == {}:
1447             print("Ignoring: No ThingType to settle new Thing in.")
1448             return
1449         type = list(world_db["ThingTypes"].keys())[0]
1450         world_db["Things"][id] = new_Thing(type)
1451
1452
1453 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1454
1455
1456 @test_Thing_id
1457 def command_tcommand(str_int):
1458     """Set T_COMMAND of selected Thing."""
1459     val = integer_test(str_int, 0)
1460     if None != val:
1461         if 0 == val or val in world_db["ThingActions"]:
1462             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1463         else:
1464             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1465
1466
1467 @test_Thing_id
1468 def command_ttype(str_int):
1469     """Set T_TYPE of selected Thing."""
1470     val = integer_test(str_int, 0)
1471     if None != val:
1472         if val in world_db["ThingTypes"]:
1473             world_db["Things"][command_tid.id]["T_TYPE"] = val
1474         else:
1475             print("Ignoring: ThingType ID belongs to no known ThingType.")
1476
1477
1478 @test_Thing_id
1479 def command_tcarries(str_int):
1480     """Append int(str_int) to T_CARRIES of selected Thing.
1481
1482     The ID int(str_int) must not be of the selected Thing, and must belong to a
1483     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1484     """
1485     val = integer_test(str_int, 0)
1486     if None != val:
1487         if val == command_tid.id:
1488             print("Ignoring: Thing cannot carry itself.")
1489         elif val in world_db["Things"] \
1490              and not world_db["Things"][val]["carried"]:
1491             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1492             world_db["Things"][val]["carried"] = True
1493         else:
1494             print("Ignoring: Thing not available for carrying.")
1495     # Note that the whole carrying structure is different from the C version:
1496     # Carried-ness is marked by a "carried" flag, not by Things containing
1497     # Things internally.
1498
1499
1500 @test_Thing_id
1501 def command_tmemthing(str_t, str_y, str_x):
1502     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1503
1504     The type must fit to an existing ThingType, and the position into the map.
1505     """
1506     type = integer_test(str_t, 0)
1507     posy = integer_test(str_y, 0, 255)
1508     posx = integer_test(str_x, 0, 255)
1509     if None != type and None != posy and None != posx:
1510         if type not in world_db["ThingTypes"] \
1511            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1512             print("Ignoring: Illegal value for thing type or position.")
1513         else:
1514             memthing = (type, posy, posx)
1515             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1516
1517
1518 def setter_map(maptype):
1519     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1520
1521     If no map of maptype exists yet, initialize it with ' ' bytes first.
1522     """
1523
1524     def valid_map_line(str_int, mapline):
1525         val = integer_test(str_int, 0, 255)
1526         if None != val:
1527             if val >= world_db["MAP_LENGTH"]:
1528                 print("Illegal value for map line number.")
1529             elif len(mapline) != world_db["MAP_LENGTH"]:
1530                 print("Map line length is unequal map width.")
1531             else:
1532                 return val
1533         return None
1534
1535     def nonThingMap_helper(str_int, mapline):
1536         val = valid_map_line(str_int, mapline)
1537         if None != val:
1538             length = world_db["MAP_LENGTH"]
1539             if not world_db["MAP"]:
1540                 map = bytearray(b' ' * (length ** 2))
1541             else:
1542                 map = world_db["MAP"]
1543             map[val * length:(val * length) + length] = mapline.encode()
1544             if not world_db["MAP"]:
1545                 world_db["MAP"] = map
1546
1547     @test_Thing_id
1548     def ThingMap_helper(str_int, mapline):
1549         val = valid_map_line(str_int, mapline)
1550         if None != val:
1551             length = world_db["MAP_LENGTH"]
1552             if not world_db["Things"][command_tid.id][maptype]:
1553                 map = bytearray(b' ' * (length ** 2))
1554             else:
1555                 map = world_db["Things"][command_tid.id][maptype]
1556             map[val * length:(val * length) + length] = mapline.encode()
1557             if not world_db["Things"][command_tid.id][maptype]:
1558                 world_db["Things"][command_tid.id][maptype] = map
1559
1560     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1561
1562
1563 def setter_tpos(axis):
1564     """Generate setter for T_POSX or  T_POSY of selected Thing.
1565
1566     If world is active, rebuilds animate things' fovmap, player's memory map.
1567     """
1568     @test_Thing_id
1569     def helper(str_int):
1570         val = integer_test(str_int, 0, 255)
1571         if None != val:
1572             if val < world_db["MAP_LENGTH"]:
1573                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1574                 if world_db["WORLD_ACTIVE"] \
1575                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1576                     build_fov_map(world_db["Things"][command_tid.id])
1577                     if 0 == command_tid.id:
1578                         update_map_memory(world_db["Things"][command_tid.id])
1579             else:
1580                 print("Ignoring: Position is outside of map.")
1581     return helper
1582
1583
1584 def command_ttid(id_string):
1585     """Set ID of ThingType to manipulate. ID unused? Create new one.
1586
1587     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1588     """
1589     id = id_setter(id_string, "ThingTypes", command_ttid)
1590     if None != id:
1591         world_db["ThingTypes"][id] = {
1592             "TT_NAME": "(none)",
1593             "TT_CONSUMABLE": 0,
1594             "TT_LIFEPOINTS": 0,
1595             "TT_PROLIFERATE": 0,
1596             "TT_START_NUMBER": 0,
1597             "TT_STORAGE": 0, # #
1598             "TT_SYMBOL": "?",
1599             "TT_CORPSE_ID": id
1600         }
1601
1602
1603 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1604
1605
1606 @test_ThingType_id
1607 def command_ttname(name):
1608     """Set TT_NAME of selected ThingType."""
1609     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1610
1611
1612 @test_ThingType_id
1613 def command_ttsymbol(char):
1614     """Set TT_SYMBOL of selected ThingType. """
1615     if 1 == len(char):
1616         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1617     else:
1618         print("Ignoring: Argument must be single character.")
1619
1620
1621 @test_ThingType_id
1622 def command_ttcorpseid(str_int):
1623     """Set TT_CORPSE_ID of selected ThingType."""
1624     val = integer_test(str_int, 0)
1625     if None != val:
1626         if val in world_db["ThingTypes"]:
1627             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1628         else:
1629             print("Ignoring: Corpse ID belongs to no known ThignType.")
1630
1631
1632 def command_taid(id_string):
1633     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1634
1635     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1636     """
1637     id = id_setter(id_string, "ThingActions", command_taid, True)
1638     if None != id:
1639         world_db["ThingActions"][id] = {
1640             "TA_EFFORT": 1,
1641             "TA_NAME": "wait"
1642         }
1643
1644
1645 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1646
1647
1648 @test_ThingAction_id
1649 def command_taname(name):
1650     """Set TA_NAME of selected ThingAction.
1651
1652     The name must match a valid thing action function. If after the name
1653     setting no ThingAction with name "wait" remains, call set_world_inactive().
1654     """
1655     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1656        or name == "pick_up":
1657         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1658         if 1 == world_db["WORLD_ACTIVE"]:
1659             wait_defined = False
1660             for id in world_db["ThingActions"]:
1661                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1662                     wait_defined = True
1663                     break
1664             if not wait_defined:
1665                 set_world_inactive()
1666     else:
1667         print("Ignoring: Invalid action name.")
1668     # In contrast to the original,naming won't map a function to a ThingAction.
1669
1670
1671 def command_ai():
1672     """Call ai() on player Thing, then turn_over()."""
1673     ai(world_db["Things"][0])
1674     turn_over()
1675
1676
1677 """Commands database.
1678
1679 Map command start tokens to ([0]) number of expected command arguments, ([1])
1680 the command's meta-ness (i.e. is it to be written to the record file, is it to
1681 be ignored in replay mode if read from server input file), and ([2]) a function
1682 to be called on it.
1683 """
1684 commands_db = {
1685     "QUIT": (0, True, command_quit),
1686     "PING": (0, True, command_ping),
1687     "THINGS_HERE": (2, True, command_thingshere),
1688     "MAKE_WORLD": (1, False, command_makeworld),
1689     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1690     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1691     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
1692     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
1693     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1694     "MAP_LENGTH": (1, False, command_maplength),
1695     "WORLD_ACTIVE": (1, False, command_worldactive),
1696     "MAP": (2, False, setter_map("MAP")),
1697     "ALTAR": (2, False, command_altar),  # #
1698     "TA_ID": (1, False, command_taid),
1699     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1700     "TA_NAME": (1, False, command_taname),
1701     "TT_ID": (1, False, command_ttid),
1702     "TT_NAME": (1, False, command_ttname),
1703     "TT_SYMBOL": (1, False, command_ttsymbol),
1704     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1705     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1706                                        0, 65535)),
1707     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1708                                          0, 255)),
1709     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1710                                         0, 255)),
1711     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1712     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
1713     "T_ID": (1, False, command_tid),
1714     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1715     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1716     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1717     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1718     "T_COMMAND": (1, False, command_tcommand),
1719     "T_TYPE": (1, False, command_ttype),
1720     "T_CARRIES": (1, False, command_tcarries),
1721     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1722     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1723     "T_MEMTHING": (3, False, command_tmemthing),
1724     "T_POSY": (1, False, setter_tpos("Y")),
1725     "T_POSX": (1, False, setter_tpos("X")),
1726     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
1727     "wait": (0, False, play_commander("wait")),
1728     "move": (1, False, play_commander("move")),
1729     "pick_up": (0, False, play_commander("pick_up")),
1730     "drop": (1, False, play_commander("drop", True)),
1731     "use": (1, False, play_commander("use", True)),
1732     "ai": (0, False, command_ai)
1733 }
1734 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1735
1736
1737 """World state database. With sane default values. (Randomness is in rand.)"""
1738 world_db = {
1739     "TURN": 0,
1740     "MAP_LENGTH": 64,
1741     "PLAYER_TYPE": 0,
1742     "WORLD_ACTIVE": 0,
1743     "GOD_MOOD": 0,  # #
1744     "GOD_FAVOR": 0,  # #
1745     "MAP": False,
1746     "ALTAR": False,
1747     "ThingActions": {},
1748     "ThingTypes": {},
1749     "Things": {}
1750 }
1751
1752 """Mapping of direction names to internal direction chars."""
1753 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1754                  "west": "s", "north-west": "w", "north-east": "e"}
1755
1756 """File IO database."""
1757 io_db = {
1758     "path_save": "save",
1759     "path_record": "record_save",
1760     "path_worldconf": "confserver/world",
1761     "path_server": "server/",
1762     "path_in": "server/in",
1763     "path_out": "server/out",
1764     "path_worldstate": "server/worldstate",
1765     "tmp_suffix": "_tmp",
1766     "kicked_by_rival": False,
1767     "worldstate_updateable": False
1768 }
1769
1770
1771 try:
1772     libpr = prep_library()
1773     rand = RandomnessIO()
1774     opts = parse_command_line_arguments()
1775     if opts.savefile:
1776         io_db["path_save"] = opts.savefile
1777         io_db["path_record"] = "record_" + opts.savefile
1778     setup_server_io()
1779     if opts.verbose:
1780         io_db["verbose"] = True
1781     if None != opts.replay:
1782         replay_game()
1783     else:
1784         play_game()
1785 except SystemExit as exit:
1786     print("ABORTING: " + exit.args[0])
1787 except:
1788     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1789     raise
1790 finally:
1791     cleanup_server_io()