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):
 510     """Return val_string if possible integer >= min and <= max, else None."""
 511     try:
 512         val = int(val_string)
 513         if val < min or val > max:
 514             raise ValueError
 515         return val
 516     except ValueError:
 517         print("Ignoring: Please use integer >= " + str(min) + " and <= " +
 518               str(max) + ".")
 519         return None
 520
 521
 522 def setter(category, key, min, max):
 523     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
 524     if category is None:
 525         def f(val_string):
 526             val = integer_test(val_string, min, max)
 527             if None != val:
 528                 world_db[key] = val
 529     else:
 530         if category == "Thing":
 531             id_store = command_tid
 532             decorator = test_Thing_id
 533         elif category == "ThingType":
 534             id_store = command_ttid
 535             decorator = test_ThingType_id
 536         elif category == "ThingAction":
 537             id_store = command_taid
 538             decorator = test_ThingAction_id
 539
 540         @decorator
 541         def f(val_string):
 542             val = integer_test(val_string, min, max)
 543             if None != val:
 544                 world_db[category + "s"][id_store.id][key] = val
 545     return f
 546
 547
 548 def build_fov_map(t):
 549     """Build Thing's FOV map."""
 550     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
 551     maptype = ctypes.c_char * len(world_db["MAP"])
 552     test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
 553                                maptype.from_buffer(t["fovmap"]),
 554                                maptype.from_buffer(world_db["MAP"]))
 555     if test:
 556         raise RuntimeError("Malloc error in build_fov_Map().")
 557
 558
 559 def decrement_lifepoints(t):
 560     """Decrement t's lifepoints by 1, and if to zero, corpse it.
 561
 562     If t is the player avatar, only blank its fovmap, so that the client may
 563     still display memory data. On non-player things, erase fovmap and memory.
 564     """
 565     t["T_LIFEPOINTS"] -= 1
 566     if 0 == t["T_LIFEPOINTS"]:
 567         t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
 568         if world_db["Things"][0] == t:
 569             t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 570             strong_write(io_db["file_out"], "LOG You die.\n")
 571         else:
 572             t["fovmap"] = False
 573             t["T_MEMMAP"] = False
 574             t["T_MEMDEPTHMAP"] = False
 575             t["T_MEMTHING"] = []
 576             strong_write(io_db["file_out"], "LOG It dies.\n")
 577
 578
 579 def mv_yx_in_dir_legal(dir, y, x):
 580     """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
 581     dir_c = dir.encode("ascii")[0]
 582     test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
 583     if -1 == test:
 584         raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
 585     return (test, libpr.result_y(), libpr.result_x())
 586
 587
 588 def actor_wait(t):
 589     """Make t do nothing (but loudly, if player avatar)."""
 590     if t == world_db["Things"][0]:
 591         strong_write(io_db["file_out"], "LOG You wait.\n")
 592
 593
 594 def actor_move(t):
 595     """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
 596     passable = False
 597     move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
 598                                      t["T_POSY"], t["T_POSX"])
 599     if 1 == move_result[0]:
 600         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
 601         passable = "." == chr(world_db["MAP"][pos])
 602         hitted = [id for id in world_db["Things"]
 603                   if world_db["Things"][id] != t
 604                   if world_db["Things"][id]["T_LIFEPOINTS"]
 605                   if world_db["Things"][id]["T_POSY"] == move_result[1]
 606                   if world_db["Things"][id]["T_POSX"] == move_result[2]]
 607         if len(hitted):
 608             hit_id = hitted[0]
 609             hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 610             hitter = "You" if t == world_db["Things"][0] else hitter_name
 611             hitted_type = world_db["Things"][hit_id]["T_TYPE"]
 612             hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
 613             hitted = "you" if hit_id == 0 else hitted_name
 614             verb = " wound " if hitter == "You" else " wounds "
 615             strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
 616                                             ".\n")
 617             decrement_lifepoints(world_db["Things"][hit_id])
 618             return
 619     dir = [dir for dir in directions_db
 620            if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
 621     if passable:
 622         t["T_POSY"] = move_result[1]
 623         t["T_POSX"] = move_result[2]
 624         for id in t["T_CARRIES"]:
 625             world_db["Things"][id]["T_POSY"] = move_result[1]
 626             world_db["Things"][id]["T_POSX"] = move_result[2]
 627         build_fov_map(t)
 628         if t == world_db["Things"][0]:
 629             strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
 630     elif t == world_db["Things"][0]:
 631         strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
 632
 633
 634 def actor_pick_up(t):
 635     """Make t pick up (topmost?) Thing from ground into inventory."""
 636     # Topmostness is actually not defined so far. Picks Thing with highest ID.
 637     ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
 638            if not world_db["Things"][id]["carried"]
 639            if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
 640            if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
 641     if len(ids):
 642         highest_id = 0
 643         for id in ids:
 644             if id > highest_id:
 645                 highest_id = id
 646         world_db["Things"][highest_id]["carried"] = True
 647         t["T_CARRIES"].append(highest_id)
 648         if t == world_db["Things"][0]:
 649             strong_write(io_db["file_out"], "LOG You pick up an object.\n")
 650     elif t == world_db["Things"][0]:
 651         err = "You try to pick up an object, but there is none."
 652         strong_write(io_db["file_out"], "LOG " + err + "\n")
 653
 654
 655 def actor_drop(t):
 656     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
 657     # TODO: Handle case where T_ARGUMENT matches nothing.
 658     if len(t["T_CARRIES"]):
 659         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 660         t["T_CARRIES"].remove(id)
 661         world_db["Things"][id]["carried"] = False
 662         if t == world_db["Things"][0]:
 663             strong_write(io_db["file_out"], "LOG You drop an object.\n")
 664     elif t == world_db["Things"][0]:
 665         err = "You try to drop an object, but you own none."
 666         strong_write(io_db["file_out"], "LOG " + err + "\n")
 667
 668
 669 def actor_use(t):
 670     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
 671     # TODO: Handle case where T_ARGUMENT matches nothing.
 672     if len(t["T_CARRIES"]):
 673         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 674         type = world_db["Things"][id]["T_TYPE"]
 675         if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
 676             t["T_CARRIES"].remove(id)
 677             del world_db["Things"][id]
 678             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 679             if t == world_db["Things"][0]:
 680                 strong_write(io_db["file_out"],
 681                              "LOG You consume this object.\n")
 682         elif t == world_db["Things"][0]:
 683             strong_write(io_db["file_out"],
 684                          "LOG You try to use this object, but fail.\n")
 685     elif t == world_db["Things"][0]:
 686         strong_write(io_db["file_out"],
 687                      "LOG You try to use an object, but you own none.\n")
 688
 689
 690 def thingproliferation(t):
 691     """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
 692
 693     Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
 694     passable and not be inhabited by a Thing of the same type, or, if Thing is
 695     animate, any other animate Thing. If there are several map cell candidates,
 696     one is selected randomly.
 697     """
 698     def test_cell(t, y, x):
 699         if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
 700             for id in [id for id in world_db["Things"]
 701                        if y == world_db["Things"][id]["T_POSY"]
 702                        if x == world_db["Things"][id]["T_POSX"]
 703                        if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
 704                        or (t["T_LIFEPOINTS"] and
 705                            world_db["Things"][id]["T_LIFEPOINTS"])]:
 706                 return False
 707             return True
 708         return False
 709     prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
 710     if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
 711         candidates = []
 712         for dir in [directions_db[key] for key in directions_db]:
 713             mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
 714             if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
 715                 candidates.append((mv_result[1], mv_result[2]))
 716         if len(candidates):
 717             i = rand.next() % len(candidates)
 718             id = id_setter(-1, "Things")
 719             newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
 720             world_db["Things"][id] = newT
 721
 722
 723 def try_healing(t):
 724     """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
 725
 726     On success, decrease satiation score by 32.
 727     """
 728     if t["T_SATIATION"] > 0 \
 729        and t["T_LIFEPOINTS"] < \
 730            world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
 731        and 0 == (rand.next() % 31) \
 732        and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
 733                               if world_db["ThingActions"][id]["TA_NAME"] ==
 734                                  "wait"][0]:
 735         t["T_LIFEPOINTS"] += 1
 736         t["T_SATIATION"] -= 32
 737         if t == world_db["Things"][0]:
 738             strong_write(io_db["file_out"], "LOG You heal.\n")
 739         else:
 740             name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 741             strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
 742
 743
 744 def hunger(t):
 745     """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
 746     if t["T_SATIATION"] > -32768:
 747         t["T_SATIATION"] -= 1
 748     testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
 749     if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
 750         raise RuntimeError("A thing that should not hunger is hungering.")
 751     stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
 752     if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
 753         if t == world_db["Things"][0]:
 754             strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
 755         else:
 756             name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 757             strong_write(io_db["file_out"], "LOG " + name +
 758                                             " suffers from hunger.\n")
 759         decrement_lifepoints(t)
 760
 761
 762 def get_dir_to_target(t, filter):
 763     """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
 764
 765     The path-wise nearest target is chosen, via the shortest available path.
 766     Target must not be t. On succcess, return positive value, else False.
 767     Filters:
 768     "a": Thing in FOV is below a certain distance, animate, but of ThingType
 769          that is not t's, and starts out weaker than t is; build path as
 770          avoiding things of t's ThingType
 771     "f": neighbor cell (not inhabited by any animate Thing) further away from
 772          animate Thing not further than x steps away and in FOV and of a
 773          ThingType that is not t's, and starts out stronger or as strong as t
 774          is currently; or (cornered), if no such flight cell, but Thing of
 775          above criteria is too near,1 a cell closer to it, or, if less near,
 776          just wait
 777     "c": Thing in memorized map is consumable
 778     "s": memory map cell with greatest-reachable degree of unexploredness
 779     """
 780
 781     def zero_score_map_where_char_on_memdepthmap(c):
 782         maptype = ctypes.c_char * len(t["T_MEMDEPTHMAP"])
 783         map = maptype.from_buffer(t["T_MEMDEPTHMAP"])
 784         test = libpr.zero_score_map_where_char_on_memdepthmap(c, map)
 785         if test:
 786             raise RuntimeError("No score map allocated for "
 787                                "zero_score_map_where_char_on_memdepthmap().")
 788
 789     def set_map_score(pos, score):
 790         test = libpr.set_map_score(pos, score)
 791         if test:
 792             raise RuntimeError("No score map allocated for set_map_score().")
 793
 794     def get_map_score(pos):
 795         result = libpr.get_map_score(pos)
 796         if result < 0:
 797             raise RuntimeError("No score map allocated for get_map_score().")
 798         return result
 799
 800     def seeing_thing():
 801         if t["fovmap"] and ("a" == filter or "f" == filter):
 802             for id in world_db["Things"]:
 803                 Thing = world_db["Things"][id]
 804                 if Thing != t and Thing["T_LIFEPOINTS"] and \
 805                    t["T_TYPE"] != Thing["T_TYPE"] and \
 806                    'v' == chr(t["fovmap"][(Thing["T_POSY"]
 807                                           * world_db["MAP_LENGTH"])
 808                                           + Thing["T_POSX"]]):
 809                     ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
 810                     if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
 811                                           t["T_LIFEPOINTS"]) \
 812                        or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
 813                                              t["T_LIFEPOINTS"]):
 814                         return True
 815         elif t["T_MEMMAP"] and "c" == filter:
 816             for mt in t["T_MEMTHING"]:
 817                 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
 818                                          + mt[2]]) \
 819                    and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
 820                     return True
 821         return False
 822
 823     def init_score_map():
 824         test = libpr.init_score_map()
 825         if test:
 826             raise RuntimeError("Malloc error in init_score_map().")
 827         ord_dot = ord(".")
 828         ord_v = ord("v")
 829         ord_blank = ord(" ")
 830         for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
 831                   if ord_dot == 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                    ord_v == 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                    ord_v == 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 ord_blank != 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             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
 866
 867     def rand_target_dir(neighbors, cmp, dirs):
 868         candidates = []
 869         n_candidates = 0
 870         for i in range(len(dirs)):
 871             if cmp == neighbors[i]:
 872                 candidates.append(dirs[i])
 873                 n_candidates += 1
 874         return candidates[rand.next() % n_candidates] if n_candidates else 0
 875
 876     def get_neighbor_scores(dirs, eye_pos):
 877         scores = []
 878         if libpr.ready_neighbor_scores(eye_pos):
 879             raise RuntimeError("No score map allocated for " +
 880                                "ready_neighbor_scores.()")
 881         for i in range(len(dirs)):
 882             scores.append(libpr.get_neighbor_score(i))
 883         return scores
 884
 885     def get_dir_from_neighbors():
 886         dir_to_target = False
 887         dirs = "edcxsw"
 888         eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
 889         neighbors = get_neighbor_scores(dirs, eye_pos)
 890         if "f" == filter:
 891             inhabited = [world_db["Things"][id]["T_POSY"]
 892                          * world_db["MAP_LENGTH"]
 893                          + world_db["Things"][id]["T_POSX"]
 894                          for id in world_db["Things"]
 895                          if world_db["Things"][id]["T_LIFEPOINTS"]]
 896             for i in range(len(dirs)):
 897                 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
 898                 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
 899                           + libpr.result_x()
 900                 for pos in [pos for pos in inhabited if pos == pos_cmp]:
 901                     neighbors[i] = 65535
 902                     break
 903         minmax_start = 0 if "f" == filter else 65535 - 1
 904         minmax_neighbor = minmax_start
 905         for i in range(len(dirs)):
 906             if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
 907                 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
 908                or ("f" != filter and minmax_neighbor > neighbors[i]):
 909                 minmax_neighbor = neighbors[i]
 910         if minmax_neighbor != minmax_start:
 911             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
 912         if "f" == filter:
 913             if not dir_to_target:
 914                 if 1 == get_map_score(eye_pos):
 915                     dir_to_target = rand_target_dir(neighbors, 0, dirs)
 916                 elif 3 >= get_map_score(eye_pos):
 917                     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
 918                                       if
 919                                       world_db["ThingActions"][id]["TA_NAME"]
 920                                          == "wait"][0]
 921                     return 1
 922             elif dir_to_target and 3 < get_map_score(eye_pos):
 923                 dir_to_target = 0
 924         elif "a" == filter and 10 <= get_map_score(eye_pos):
 925             dir_to_target = 0
 926         return dir_to_target
 927
 928     dir_to_target = False
 929     mem_depth_c = b' '
 930     run_i = 9 + 1 if "s" == filter else 1
 931     while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
 932         run_i -= 1
 933         init_score_map()
 934         mem_depth_c = b'9' if b' ' == mem_depth_c \
 935                            else bytes([mem_depth_c[0] - 1])
 936         if libpr.dijkstra_map():
 937             raise RuntimeError("No score map allocated for dijkstra_map().")
 938         dir_to_target = get_dir_from_neighbors()
 939         libpr.free_score_map()
 940         if dir_to_target and str == type(dir_to_target):
 941             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
 942                               if world_db["ThingActions"][id]["TA_NAME"]
 943                                  == "move"][0]
 944             t["T_ARGUMENT"] = ord(dir_to_target)
 945     return dir_to_target
 946
 947
 948 def standing_on_consumable(t):
 949     """Return True/False whether t is standing on a consumable."""
 950     for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
 951                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
 952                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
 953                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
 954                           ["TT_CONSUMABLE"]]:
 955         return True
 956     return False
 957
 958
 959 def get_inventory_slot_to_consume(t):
 960     """Return slot Id of strongest consumable in t's inventory, else -1."""
 961     cmp_consumability = 0
 962     selection = -1
 963     i = 0
 964     for id in t["T_CARRIES"]:
 965         type = world_db["Things"][id]["T_TYPE"]
 966         if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
 967             cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 968             selection = i
 969         i += 1
 970     return selection
 971
 972
 973 def ai(t):
 974     """Determine next command/argment for actor t via AI algorithms.
 975
 976     AI will look for, and move towards, enemies (animate Things not of their
 977     own ThingType); if they see none, they will consume consumables in their
 978     inventory; if there are none, they will pick up what they stand on if they
 979     stand on consumables; if they stand on none, they will move towards the
 980     next consumable they see or remember on the map; if they see or remember
 981     none, they will explore parts of the map unseen since ever or for at least
 982     one turn; if there is nothing to explore, they will simply wait.
 983     """
 984     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
 985                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
 986     if not get_dir_to_target(t, "f"):
 987         sel = get_inventory_slot_to_consume(t)
 988         if -1 != sel:
 989             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
 990                               if world_db["ThingActions"][id]["TA_NAME"]
 991                                  == "use"][0]
 992             t["T_ARGUMENT"] = sel
 993         elif standing_on_consumable(t):
 994             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
 995                               if world_db["ThingActions"][id]["TA_NAME"]
 996                                  == "pick_up"][0]
 997         elif (not get_dir_to_target(t, "c")) and \
 998              (not get_dir_to_target(t, "a")):
 999             get_dir_to_target(t, "s")
1000
1001
1002 def turn_over():
1003     """Run game world and its inhabitants until new player input expected."""
1004     id = 0
1005     whilebreaker = False
1006     while world_db["Things"][0]["T_LIFEPOINTS"]:
1007         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1008             if not id in world_db["Things"] or \
1009                world_db["Things"][id]["carried"]:   # May have been consumed or
1010                 continue                            # picked up during turn …
1011             Thing = world_db["Things"][id]
1012             if Thing["T_LIFEPOINTS"]:
1013                 if not Thing["T_COMMAND"]:
1014                     update_map_memory(Thing)
1015                     if 0 == id:
1016                         whilebreaker = True
1017                         break
1018                     ai(Thing)
1019                 try_healing(Thing)
1020                 Thing["T_PROGRESS"] += 1
1021                 taid = [a for a in world_db["ThingActions"]
1022                           if a == Thing["T_COMMAND"]][0]
1023                 ThingAction = world_db["ThingActions"][taid]
1024                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1025                     eval("actor_" + ThingAction["TA_NAME"])(Thing)
1026                     Thing["T_COMMAND"] = 0
1027                     Thing["T_PROGRESS"] = 0
1028                 hunger(Thing)
1029             thingproliferation(Thing)
1030         if whilebreaker:
1031             break
1032         world_db["TURN"] += 1
1033
1034
1035 def new_Thing(type, pos=(0, 0)):
1036     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1037     thing = {
1038         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1039         "T_ARGUMENT": 0,
1040         "T_PROGRESS": 0,
1041         "T_SATIATION": 0,
1042         "T_COMMAND": 0,
1043         "T_TYPE": type,
1044         "T_POSY": pos[0],
1045         "T_POSX": pos[1],
1046         "T_CARRIES": [],
1047         "carried": False,
1048         "T_MEMTHING": [],
1049         "T_MEMMAP": False,
1050         "T_MEMDEPTHMAP": False,
1051         "fovmap": False
1052     }
1053     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1054         build_fov_map(thing)
1055     return thing
1056
1057
1058 def id_setter(id, category, id_store=False, start_at_1=False):
1059     """Set ID of object of category to manipulate ID unused? Create new one.
1060
1061     The ID is stored as id_store.id (if id_store is set). If the integer of the
1062     input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
1063     32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
1064     >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
1065     new object is created, otherwise the new object's ID.
1066     """
1067     min = 0 if start_at_1 else -32768
1068     max = 255 if start_at_1 else 32767
1069     if str == type(id):
1070         id = integer_test(id, min, max)
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 or id > 255)):
1079                 id = -1
1080                 while 1:
1081                     id = id + 1
1082                     if id not in world_db[category]:
1083                         break
1084                 if id > 255:
1085                     print("Ignoring: "
1086                           "No unused ID available to add to ID list.")
1087                     return None
1088             if id_store:
1089                 id_store.id = id
1090     return id
1091
1092
1093 def command_ping():
1094     """Send PONG line to server output file."""
1095     strong_write(io_db["file_out"], "PONG\n")
1096
1097
1098 def command_quit():
1099     """Abort server process."""
1100     save_world()
1101     atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1102     raise SystemExit("received QUIT command")
1103
1104
1105 def command_thingshere(str_y, str_x):
1106     """Write to out file list of Things known to player at coordinate y, x."""
1107     if world_db["WORLD_ACTIVE"]:
1108         y = integer_test(str_y, 0, 255)
1109         x = integer_test(str_x, 0, 255)
1110         length = world_db["MAP_LENGTH"]
1111         if None != y and None != x and y < length and x < length:
1112             pos = (y * world_db["MAP_LENGTH"]) + x
1113             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1114             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1115                 for id in world_db["Things"]:
1116                     if y == world_db["Things"][id]["T_POSY"] \
1117                        and x == world_db["Things"][id]["T_POSX"] \
1118                        and not world_db["Things"][id]["carried"]:
1119                         type = world_db["Things"][id]["T_TYPE"]
1120                         name = world_db["ThingTypes"][type]["TT_NAME"]
1121                         strong_write(io_db["file_out"], name + "\n")
1122             else:
1123                 for mt in world_db["Things"][0]["T_MEMTHING"]:
1124                     if y == mt[1] and x == mt[2]:
1125                         name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1126                         strong_write(io_db["file_out"], name + "\n")
1127             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1128         else:
1129             print("Ignoring: Invalid map coordinates.")
1130     else:
1131         print("Ignoring: Command only works on existing worlds.")
1132
1133
1134 def play_commander(action, args=False):
1135     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1136
1137     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1138     """
1139
1140     def set_command():
1141         id = [x for x in world_db["ThingActions"]
1142                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1143         world_db["Things"][0]["T_COMMAND"] = id
1144         turn_over()
1145
1146     def set_command_and_argument_int(str_arg):
1147         val = integer_test(str_arg, 0, 255)
1148         if None != val:
1149             world_db["Things"][0]["T_ARGUMENT"] = val
1150             set_command()
1151
1152     def set_command_and_argument_movestring(str_arg):
1153         if str_arg in directions_db:
1154             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1155             set_command()
1156         else:
1157             print("Ignoring: Argument must be valid direction string.")
1158
1159     if action == "move":
1160         return set_command_and_argument_movestring
1161     elif args:
1162         return set_command_and_argument_int
1163     else:
1164         return set_command
1165
1166
1167 def command_seedrandomness(seed_string):
1168     """Set rand seed to int(seed_string)."""
1169     val = integer_test(seed_string, 0, 4294967295)
1170     if None != val:
1171         rand.seed = val
1172
1173
1174 def command_seedmap(seed_string):
1175     """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1176     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1177     remake_map()
1178
1179
1180 def command_makeworld(seed_string):
1181     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1182
1183     Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1184     "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1185     TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1186     and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1187     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1188     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1189     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1190     """
1191
1192     def free_pos():
1193         i = 0
1194         while 1:
1195             err = "Space to put thing on too hard to find. Map too small?"
1196             while 1:
1197                 y = rand.next() % world_db["MAP_LENGTH"]
1198                 x = rand.next() % world_db["MAP_LENGTH"]
1199                 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1200                     break
1201                 i += 1
1202                 if i == 65535:
1203                     raise SystemExit(err)
1204             # Replica of C code, wrongly ignores animatedness of new Thing.
1205             pos_clear = (0 == len([id for id in world_db["Things"]
1206                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1207                                    if world_db["Things"][id]["T_POSY"] == y
1208                                    if world_db["Things"][id]["T_POSX"] == x]))
1209             if pos_clear:
1210                 break
1211         return (y, x)
1212
1213     val = integer_test(seed_string, 0, 4294967295)
1214     if None == val:
1215         return
1216     rand.seed = val
1217     world_db["SEED_MAP"] = val
1218     player_will_be_generated = False
1219     playertype = world_db["PLAYER_TYPE"]
1220     for ThingType in world_db["ThingTypes"]:
1221         if playertype == ThingType:
1222             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1223                 player_will_be_generated = True
1224             break
1225     if not player_will_be_generated:
1226         print("Ignoring beyond SEED_MAP: " +
1227               "No player type with start number >0 defined.")
1228         return
1229     wait_action = False
1230     for ThingAction in world_db["ThingActions"]:
1231         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1232             wait_action = True
1233     if not wait_action:
1234         print("Ignoring beyond SEED_MAP: " +
1235               "No thing action with name 'wait' defined.")
1236         return
1237     world_db["Things"] = {}
1238     remake_map()
1239     world_db["WORLD_ACTIVE"] = 1
1240     world_db["TURN"] = 1
1241     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1242         id = id_setter(-1, "Things")
1243         world_db["Things"][id] = new_Thing(playertype, free_pos())
1244     update_map_memory(world_db["Things"][0])
1245     for type in world_db["ThingTypes"]:
1246         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1247             if type != playertype:
1248                 id = id_setter(-1, "Things")
1249                 world_db["Things"][id] = new_Thing(type, free_pos())
1250     strong_write(io_db["file_out"], "NEW_WORLD\n")
1251
1252
1253 def command_maplength(maplength_string):
1254     """Redefine map length. Invalidate map, therefore lose all things on it."""
1255     val = integer_test(maplength_string, 1, 256)
1256     if None != val:
1257         world_db["MAP_LENGTH"] = val
1258         set_world_inactive()
1259         world_db["Things"] = {}
1260         libpr.set_maplength(val)
1261
1262
1263 def command_worldactive(worldactive_string):
1264     """Toggle world_db["WORLD_ACTIVE"] if possible.
1265
1266     An active world can always be set inactive. An inactive world can only be
1267     set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1268     activation, rebuild all Things' FOVs, and the player's map memory.
1269     """
1270     # In original version, map existence was also tested (unnecessarily?).
1271     val = integer_test(worldactive_string, 0, 1)
1272     if val:
1273         if 0 != world_db["WORLD_ACTIVE"]:
1274             if 0 == val:
1275                 set_world_inactive()
1276             else:
1277                 print("World already active.")
1278         elif 0 == world_db["WORLD_ACTIVE"]:
1279             wait_exists = False
1280             for ThingAction in world_db["ThingActions"]:
1281                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1282                     wait_exists = True
1283                     break
1284             player_exists = False
1285             for Thing in world_db["Things"]:
1286                 if 0 == Thing:
1287                     player_exists = True
1288                     break
1289             if wait_exists and player_exists:
1290                 for id in world_db["Things"]:
1291                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1292                         build_fov_map(world_db["Things"][id])
1293                         if 0 == id:
1294                             update_map_memory(world_db["Things"][id], False)
1295                 world_db["WORLD_ACTIVE"] = 1
1296
1297
1298 def test_for_id_maker(object, category):
1299     """Return decorator testing for object having "id" attribute."""
1300     def decorator(f):
1301         def helper(*args):
1302             if hasattr(object, "id"):
1303                 f(*args)
1304             else:
1305                 print("Ignoring: No " + category +
1306                       " defined to manipulate yet.")
1307         return helper
1308     return decorator
1309
1310
1311 def command_tid(id_string):
1312     """Set ID of Thing to manipulate. ID unused? Create new one.
1313
1314     Default new Thing's type to the first available ThingType, others: zero.
1315     """
1316     id = id_setter(id_string, "Things", command_tid)
1317     if None != id:
1318         if world_db["ThingTypes"] == {}:
1319             print("Ignoring: No ThingType to settle new Thing in.")
1320             return
1321         type = list(world_db["ThingTypes"].keys())[0]
1322         world_db["Things"][id] = new_Thing(type)
1323
1324
1325 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1326
1327
1328 @test_Thing_id
1329 def command_tcommand(str_int):
1330     """Set T_COMMAND of selected Thing."""
1331     val = integer_test(str_int, 0, 255)
1332     if None != val:
1333         if 0 == val or val in world_db["ThingActions"]:
1334             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1335         else:
1336             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1337
1338
1339 @test_Thing_id
1340 def command_ttype(str_int):
1341     """Set T_TYPE of selected Thing."""
1342     val = integer_test(str_int, 0, 255)
1343     if None != val:
1344         if val in world_db["ThingTypes"]:
1345             world_db["Things"][command_tid.id]["T_TYPE"] = val
1346         else:
1347             print("Ignoring: ThingType ID belongs to no known ThingType.")
1348
1349
1350 @test_Thing_id
1351 def command_tcarries(str_int):
1352     """Append int(str_int) to T_CARRIES of selected Thing.
1353
1354     The ID int(str_int) must not be of the selected Thing, and must belong to a
1355     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1356     """
1357     val = integer_test(str_int, 0, 255)
1358     if None != val:
1359         if val == command_tid.id:
1360             print("Ignoring: Thing cannot carry itself.")
1361         elif val in world_db["Things"] \
1362              and not world_db["Things"][val]["carried"]:
1363             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1364             world_db["Things"][val]["carried"] = True
1365         else:
1366             print("Ignoring: Thing not available for carrying.")
1367     # Note that the whole carrying structure is different from the C version:
1368     # Carried-ness is marked by a "carried" flag, not by Things containing
1369     # Things internally.
1370
1371
1372 @test_Thing_id
1373 def command_tmemthing(str_t, str_y, str_x):
1374     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1375
1376     The type must fit to an existing ThingType, and the position into the map.
1377     """
1378     type = integer_test(str_t, 0, 255)
1379     posy = integer_test(str_y, 0, 255)
1380     posx = integer_test(str_x, 0, 255)
1381     if None != type and None != posy and None != posx:
1382         if type not in world_db["ThingTypes"] \
1383            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1384             print("Ignoring: Illegal value for thing type or position.")
1385         else:
1386             memthing = (type, posy, posx)
1387             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1388
1389
1390 def setter_map(maptype):
1391     """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1392
1393     If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1394     """
1395     @test_Thing_id
1396     def helper(str_int, mapline):
1397         val = integer_test(str_int, 0, 255)
1398         if None != val:
1399             if val >= world_db["MAP_LENGTH"]:
1400                 print("Illegal value for map line number.")
1401             elif len(mapline) != world_db["MAP_LENGTH"]:
1402                 print("Map line length is unequal map width.")
1403             else:
1404                 length = world_db["MAP_LENGTH"]
1405                 map = None
1406                 if not world_db["Things"][command_tid.id][maptype]:
1407                     map = bytearray(b' ' * (length ** 2))
1408                 else:
1409                     map = world_db["Things"][command_tid.id][maptype]
1410                 map[val * length:(val * length) + length] = mapline.encode()
1411                 world_db["Things"][command_tid.id][maptype] = map
1412     return helper
1413
1414
1415 def setter_tpos(axis):
1416     """Generate setter for T_POSX or  T_POSY of selected Thing.
1417
1418     If world is active, rebuilds animate things' fovmap, player's memory map.
1419     """
1420     @test_Thing_id
1421     def helper(str_int):
1422         val = integer_test(str_int, 0, 255)
1423         if None != val:
1424             if val < world_db["MAP_LENGTH"]:
1425                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1426                 if world_db["WORLD_ACTIVE"] \
1427                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1428                     build_fov_map(world_db["Things"][command_tid.id])
1429                     if 0 == command_tid.id:
1430                         update_map_memory(world_db["Things"][command_tid.id])
1431             else:
1432                 print("Ignoring: Position is outside of map.")
1433     return helper
1434
1435
1436 def command_ttid(id_string):
1437     """Set ID of ThingType to manipulate. ID unused? Create new one.
1438
1439     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1440     """
1441     id = id_setter(id_string, "ThingTypes", command_ttid)
1442     if None != id:
1443         world_db["ThingTypes"][id] = {
1444             "TT_NAME": "(none)",
1445             "TT_CONSUMABLE": 0,
1446             "TT_LIFEPOINTS": 0,
1447             "TT_PROLIFERATE": 0,
1448             "TT_START_NUMBER": 0,
1449             "TT_SYMBOL": "?",
1450             "TT_CORPSE_ID": id
1451         }
1452
1453
1454 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1455
1456
1457 @test_ThingType_id
1458 def command_ttname(name):
1459     """Set TT_NAME of selected ThingType."""
1460     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1461
1462
1463 @test_ThingType_id
1464 def command_ttsymbol(char):
1465     """Set TT_SYMBOL of selected ThingType. """
1466     if 1 == len(char):
1467         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1468     else:
1469         print("Ignoring: Argument must be single character.")
1470
1471
1472 @test_ThingType_id
1473 def command_ttcorpseid(str_int):
1474     """Set TT_CORPSE_ID of selected ThingType."""
1475     val = integer_test(str_int, 0, 255)
1476     if None != val:
1477         if val in world_db["ThingTypes"]:
1478             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1479         else:
1480             print("Ignoring: Corpse ID belongs to no known ThignType.")
1481
1482
1483 def command_taid(id_string):
1484     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1485
1486     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1487     """
1488     id = id_setter(id_string, "ThingActions", command_taid, True)
1489     if None != id:
1490         world_db["ThingActions"][id] = {
1491             "TA_EFFORT": 1,
1492             "TA_NAME": "wait"
1493         }
1494
1495
1496 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1497
1498
1499 @test_ThingAction_id
1500 def command_taname(name):
1501     """Set TA_NAME of selected ThingAction.
1502
1503     The name must match a valid thing action function. If after the name
1504     setting no ThingAction with name "wait" remains, call set_world_inactive().
1505     """
1506     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1507        or name == "pick_up":
1508         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1509         if 1 == world_db["WORLD_ACTIVE"]:
1510             wait_defined = False
1511             for id in world_db["ThingActions"]:
1512                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1513                     wait_defined = True
1514                     break
1515             if not wait_defined:
1516                 set_world_inactive()
1517     else:
1518         print("Ignoring: Invalid action name.")
1519     # In contrast to the original,naming won't map a function to a ThingAction.
1520
1521
1522 def command_ai():
1523     """Call ai() on player Thing, then turn_over()."""
1524     ai(world_db["Things"][0])
1525     turn_over()
1526
1527
1528 """Commands database.
1529
1530 Map command start tokens to ([0]) number of expected command arguments, ([1])
1531 the command's meta-ness (i.e. is it to be written to the record file, is it to
1532 be ignored in replay mode if read from server input file), and ([2]) a function
1533 to be called on it.
1534 """
1535 commands_db = {
1536     "QUIT": (0, True, command_quit),
1537     "PING": (0, True, command_ping),
1538     "THINGS_HERE": (2, True, command_thingshere),
1539     "MAKE_WORLD": (1, False, command_makeworld),
1540     "SEED_MAP": (1, False, command_seedmap),
1541     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1542     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1543     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1544     "MAP_LENGTH": (1, False, command_maplength),
1545     "WORLD_ACTIVE": (1, False, command_worldactive),
1546     "TA_ID": (1, False, command_taid),
1547     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1548     "TA_NAME": (1, False, command_taname),
1549     "TT_ID": (1, False, command_ttid),
1550     "TT_NAME": (1, False, command_ttname),
1551     "TT_SYMBOL": (1, False, command_ttsymbol),
1552     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1553     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1554                                        0, 65535)),
1555     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1556                                          0, 255)),
1557     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1558                                         0, 255)),
1559     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1560     "T_ID": (1, False, command_tid),
1561     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1562     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1563     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1564     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1565     "T_COMMAND": (1, False, command_tcommand),
1566     "T_TYPE": (1, False, command_ttype),
1567     "T_CARRIES": (1, False, command_tcarries),
1568     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1569     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1570     "T_MEMTHING": (3, False, command_tmemthing),
1571     "T_POSY": (1, False, setter_tpos("Y")),
1572     "T_POSX": (1, False, setter_tpos("X")),
1573     "wait": (0, False, play_commander("wait")),
1574     "move": (1, False, play_commander("move")),
1575     "pick_up": (0, False, play_commander("pick_up")),
1576     "drop": (1, False, play_commander("drop", True)),
1577     "use": (1, False, play_commander("use", True)),
1578     "ai": (0, False, command_ai)
1579 }
1580
1581
1582 """World state database. With sane default values. (Randomness is in rand.)"""
1583 world_db = {
1584     "TURN": 0,
1585     "MAP_LENGTH": 64,
1586     "SEED_MAP": 0,
1587     "PLAYER_TYPE": 0,
1588     "WORLD_ACTIVE": 0,
1589     "ThingActions": {},
1590     "ThingTypes": {},
1591     "Things": {}
1592 }
1593
1594 """Mapping of direction names to internal direction chars."""
1595 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1596                  "west": "s", "north-west": "w", "north-east": "e"}
1597
1598 """File IO database."""
1599 io_db = {
1600     "path_save": "save",
1601     "path_record": "record_save",
1602     "path_worldconf": "confserver/world",
1603     "path_server": "server/",
1604     "path_in": "server/in",
1605     "path_out": "server/out",
1606     "path_worldstate": "server/worldstate",
1607     "tmp_suffix": "_tmp",
1608     "kicked_by_rival": False,
1609     "worldstate_updateable": False
1610 }
1611
1612
1613 try:
1614     libpr = prep_library()
1615     rand = RandomnessIO()
1616     opts = parse_command_line_arguments()
1617     if opts.savefile:
1618         io_db["path_save"] = opts.savefile
1619         io_db["path_record"] = "record_" + opts.savefile
1620     setup_server_io()
1621     if opts.verbose:
1622         io_db["verbose"] = True
1623     if None != opts.replay:
1624         replay_game()
1625     else:
1626         play_game()
1627 except SystemExit as exit:
1628     print("ABORTING: " + exit.args[0])
1629 except:
1630     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1631     raise
1632 finally:
1633     cleanup_server_io()