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

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