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

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