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

   1 import argparse
   2 import errno
   3 import os
   4 import shlex
   5 import shutil
   6 import time
   7 import ctypes
   8
   9
  10 class RandomnessIO:
  11     """"Interface to libplomrogue's pseudo-randomness generator."""
  12
  13     def set_seed(self, seed):
  14         libpr.seed_rrand(1, seed)
  15
  16     def get_seed(self):
  17         return libpr.seed_rrand(0, 0)
  18
  19     def next(self):
  20         return libpr.rrand()
  21
  22     seed = property(get_seed, set_seed)
  23
  24
  25 def prep_library():
  26     """Prepare ctypes library at ./libplomrogue.so"""
  27     libpath = ("./libplomrogue.so")
  28     if not os.access(libpath, os.F_OK):
  29         raise SystemExit("No library " + libpath + ", run ./compile.sh first?")
  30     libpr = ctypes.cdll.LoadLibrary(libpath)
  31     libpr.seed_rrand.argtypes = [ctypes.c_uint8, ctypes.c_uint32]
  32     libpr.seed_rrand.restype = ctypes.c_uint32
  33     libpr.rrand.argtypes = []
  34     libpr.rrand.restype = ctypes.c_uint16
  35     libpr.set_maplength.argtypes = [ctypes.c_uint16]
  36     libpr.mv_yx_in_dir_legal_wrap.argtypes = [ctypes.c_char, ctypes.c_uint8,
  37                                               ctypes.c_uint8]
  38     libpr.mv_yx_in_dir_legal_wrap.restype = ctypes.c_uint8
  39     libpr.result_y.restype = ctypes.c_uint8
  40     libpr.result_x.restype = ctypes.c_uint8
  41     libpr.set_maplength(world_db["MAP_LENGTH"])
  42     libpr.build_fov_map.argtypes = [ctypes.c_uint8, ctypes.c_uint8,
  43                                     ctypes.c_char_p, ctypes.c_char_p]
  44     libpr.build_fov_map.restype = ctypes.c_uint8
  45     return libpr
  46
  47
  48 def strong_write(file, string):
  49     """Apply write(string), flush(), and os.fsync() to file."""
  50     file.write(string)
  51     file.flush()
  52     os.fsync(file)
  53
  54
  55 def setup_server_io():
  56     """Fill IO files DB with proper file( path)s. Write process IO test string.
  57
  58     Ensure IO files directory at server/. Remove any old input file if found.
  59     Set up new input file for reading, and new output file for writing. Start
  60     output file with process hash line of format PID + " " + floated UNIX time
  61     (io_db["teststring"]). Raise SystemExit if file is found at path of either
  62     record or save file plus io_db["tmp_suffix"].
  63     """
  64     def detect_atomic_leftover(path, tmp_suffix):
  65         path_tmp = path + tmp_suffix
  66         msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
  67               "aborted previous attempt to write '" + path + "'. Aborting " \
  68              "until matter is resolved by removing it from its current path."
  69         if os.access(path_tmp, os.F_OK):
  70             raise SystemExit(msg)
  71     io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
  72     os.makedirs(io_db["path_server"], exist_ok=True)
  73     io_db["file_out"] = open(io_db["path_out"], "w")
  74     strong_write(io_db["file_out"], io_db["teststring"] + "\n")
  75     if os.access(io_db["path_in"], os.F_OK):
  76         os.remove(io_db["path_in"])
  77     io_db["file_in"] = open(io_db["path_in"], "w")
  78     io_db["file_in"].close()
  79     io_db["file_in"] = open(io_db["path_in"], "r")
  80     detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
  81     detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
  82
  83
  84 def cleanup_server_io():
  85     """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
  86     def helper(file_key, path_key):
  87         if file_key in io_db:
  88             io_db[file_key].close()
  89             if not io_db["kicked_by_rival"] \
  90                and os.access(io_db[path_key], os.F_OK):
  91                 os.remove(io_db[path_key])
  92     helper("file_out", "path_out")
  93     helper("file_in", "path_in")
  94     helper("file_worldstate", "path_worldstate")
  95     if "file_record" in io_db:
  96         io_db["file_record"].close()
  97
  98
  99 def obey(command, prefix, replay=False, do_record=False):
 100     """Call function from commands_db mapped to command's first token.
 101
 102     Tokenize command string with shlex.split(comments=True). If replay is set,
 103     a non-meta command from the commands_db merely triggers obey() on the next
 104     command from the records file. If not, non-meta commands set
 105     io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
 106     do_record is set, are recorded via record(), and save_world() is called.
 107     The prefix string is inserted into the server's input message between its
 108     beginning 'input ' & ':'. All activity is preceded by a server_test() call.
 109     """
 110     server_test()
 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                 record(command)
 134                 save_world()
 135             io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
 136     elif 0 != len(tokens):
 137         print("Invalid command/argument, or bad number of tokens.")
 138
 139
 140 def atomic_write(path, text, do_append=False):
 141     """Atomic write of text to file at path, appended if do_append is set."""
 142     path_tmp = path + io_db["tmp_suffix"]
 143     mode = "w"
 144     if do_append:
 145         mode = "a"
 146         if os.access(path, os.F_OK):
 147             shutil.copyfile(path, path_tmp)
 148     file = open(path_tmp, mode)
 149     strong_write(file, text)
 150     file.close()
 151     if os.access(path, os.F_OK):
 152         os.remove(path)
 153     os.rename(path_tmp, path)
 154
 155
 156 def record(command):
 157     """Append command string plus newline to record file. (Atomic.)"""
 158     # This misses some optimizations from the original record(), namely only
 159     # finishing the atomic write with expensive flush() and fsync() every 15
 160     # seconds unless explicitely forced. Implement as needed.
 161     atomic_write(io_db["path_record"], command + "\n", do_append=True)
 162
 163
 164 def save_world():
 165     """Save all commands needed to reconstruct current world state."""
 166     # TODO: Misses same optimizations as record() from the original record().
 167
 168     def quote(string):
 169         string = string.replace("\u005C", '\u005C\u005C')
 170         return '"' + string.replace('"', '\u005C"') + '"'
 171
 172     def mapsetter(key):
 173         def helper(id):
 174             string = ""
 175             if world_db["Things"][id][key]:
 176                 map = world_db["Things"][id][key]
 177                 length = world_db["MAP_LENGTH"]
 178                 for i in range(length):
 179                     line = map[i * length:(i * length) + length].decode()
 180                     string = string + key + " " + str(i) + " " + quote(line) \
 181                              + "\n"
 182             return string
 183         return helper
 184
 185     def memthing(id):
 186         string = ""
 187         for memthing in world_db["Things"][id]["T_MEMTHING"]:
 188             string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
 189                      str(memthing[1]) + " " + str(memthing[2]) + "\n"
 190         return string
 191
 192     def helper(category, id_string, special_keys={}):
 193         string = ""
 194         for id in world_db[category]:
 195             string = string + id_string + " " + str(id) + "\n"
 196             for key in world_db[category][id]:
 197                 if not key in special_keys:
 198                     x = world_db[category][id][key]
 199                     argument = quote(x) if str == type(x) else str(x)
 200                     string = string + key + " " + argument + "\n"
 201                 elif special_keys[key]:
 202                     string = string + special_keys[key](id)
 203         return string
 204
 205     string = ""
 206     for key in world_db:
 207         if dict != type(world_db[key]) and key != "MAP":
 208             string = string + key + " " + str(world_db[key]) + "\n"
 209     string = string + helper("ThingActions", "TA_ID")
 210     string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
 211     for id in world_db["ThingTypes"]:
 212         string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
 213                  str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
 214     string = string + helper("Things", "T_ID",
 215                              {"T_CARRIES": False, "carried": False,
 216                               "T_MEMMAP": mapsetter("T_MEMMAP"),
 217                               "T_MEMTHING": memthing, "fovmap": False,
 218                               "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
 219     for id in world_db["Things"]:
 220         if [] != world_db["Things"][id]["T_CARRIES"]:
 221             string = string + "T_ID " + str(id) + "\n"
 222             for carried_id in world_db["Things"][id]["T_CARRIES"]:
 223                 string = string + "T_CARRIES " + str(carried_id) + "\n"
 224     string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
 225              "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
 226     atomic_write(io_db["path_save"], string)
 227
 228
 229 def obey_lines_in_file(path, name, do_record=False):
 230     """Call obey() on each line of path's file, use name in input prefix."""
 231     file = open(path, "r")
 232     line_n = 1
 233     for line in file.readlines():
 234         obey(line.rstrip(), name + "file line " + str(line_n),
 235              do_record=do_record)
 236         line_n = line_n + 1
 237     file.close()
 238
 239
 240 def parse_command_line_arguments():
 241     """Return settings values read from command line arguments."""
 242     parser = argparse.ArgumentParser()
 243     parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
 244                         action='store')
 245     opts, unknown = parser.parse_known_args()
 246     return opts
 247
 248
 249 def server_test():
 250     """Ensure valid server out file belonging to current process.
 251
 252     This is done by comparing io_db["teststring"] to what's found at the start
 253     of the current file at io_db["path_out"]. On failure, set
 254     io_db["kicked_by_rival"] and raise SystemExit.
 255     """
 256     if not os.access(io_db["path_out"], os.F_OK):
 257         raise SystemExit("Server output file has disappeared.")
 258     file = open(io_db["path_out"], "r")
 259     test = file.readline().rstrip("\n")
 260     file.close()
 261     if test != io_db["teststring"]:
 262         io_db["kicked_by_rival"] = True
 263         msg = "Server test string in server output file does not match. This" \
 264               " indicates that the current server process has been " \
 265               "superseded by another one."
 266         raise SystemExit(msg)
 267
 268
 269 def read_command():
 270     """Return next newline-delimited command from server in file.
 271
 272     Keep building return string until a newline is encountered. Pause between
 273     unsuccessful reads, and after too much waiting, run server_test().
 274     """
 275     wait_on_fail = 0.03333
 276     max_wait = 5
 277     now = time.time()
 278     command = ""
 279     while True:
 280         add = io_db["file_in"].readline()
 281         if len(add) > 0:
 282             command = command + add
 283             if len(command) > 0 and "\n" == command[-1]:
 284                 command = command[:-1]
 285                 break
 286         else:
 287             time.sleep(wait_on_fail)
 288             if now + max_wait < time.time():
 289                 server_test()
 290                 now = time.time()
 291     return command
 292
 293
 294 def try_worldstate_update():
 295     """Write worldstate file if io_db["worldstate_updateable"] is set."""
 296     if io_db["worldstate_updateable"]:
 297
 298         def draw_visible_Things(map, run):
 299             for id in world_db["Things"]:
 300                 type = world_db["Things"][id]["T_TYPE"]
 301                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 302                 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
 303                 if (0 == run and not consumable and not alive) \
 304                    or (1 == run and consumable and not alive) \
 305                    or (2 == run and alive):
 306                     y = world_db["Things"][id]["T_POSY"]
 307                     x = world_db["Things"][id]["T_POSX"]
 308                     fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
 309                     if 'v' == chr(fovflag):
 310                         c = world_db["ThingTypes"][type]["TT_SYMBOL"]
 311                         map[(y * length) + x] = ord(c)
 312
 313         def write_map(string, map):
 314             for i in range(length):
 315                 line = map[i * length:(i * length) + length].decode()
 316                 string = string + line + "\n"
 317             return string
 318
 319         inventory = ""
 320         if [] == world_db["Things"][0]["T_CARRIES"]:
 321             inventory = "(none)\n"
 322         else:
 323             for id in world_db["Things"][0]["T_CARRIES"]:
 324                 type_id = world_db["Things"][id]["T_TYPE"]
 325                 name = world_db["ThingTypes"][type_id]["TT_NAME"]
 326                 inventory = inventory + name + "\n"
 327         string = str(world_db["TURN"]) + "\n" + \
 328                  str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
 329                  str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
 330                  inventory + "%\n" + \
 331                  str(world_db["Things"][0]["T_POSY"]) + "\n" + \
 332                  str(world_db["Things"][0]["T_POSX"]) + "\n" + \
 333                  str(world_db["MAP_LENGTH"]) + "\n"
 334         length = world_db["MAP_LENGTH"]
 335         fov = bytearray(b' ' * (length ** 2))
 336         for pos in range(length ** 2):
 337             if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
 338                 fov[pos] = world_db["MAP"][pos]
 339         for i in range(3):
 340             draw_visible_Things(fov, i)
 341         string = write_map(string, fov)
 342         mem = world_db["Things"][0]["T_MEMMAP"][:]
 343         for i in range(2):
 344             for memthing in world_db["Things"][0]["T_MEMTHING"]:
 345                 type = world_db["Things"][memthing[0]]["T_TYPE"]
 346                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 347                 if (i == 0 and not consumable) or (i == 1 and consumable):
 348                     c = world_db["ThingTypes"][type]["TT_SYMBOL"]
 349                     mem[(memthing[1] * length) + memthing[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     world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
 440     length = world_db["MAP_LENGTH"]
 441     add_half_width = (not (length % 2)) * int(length / 2)
 442     world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
 443     while (1):
 444         y = rand.next() % length
 445         x = rand.next() % length
 446         pos = (y * length) + x
 447         if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
 448             if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
 449                 break
 450             world_db["MAP"][pos] = ord(".")
 451     n_trees = int((length ** 2) / 16)
 452     i_trees = 0
 453     while (i_trees <= n_trees):
 454         single_allowed = rand.next() % 32
 455         y = rand.next() % length
 456         x = rand.next() % length
 457         pos = (y * length) + x
 458         if "." == chr(world_db["MAP"][pos]) \
 459           and ((not single_allowed) or is_neighbor((y, x), "X")):
 460             world_db["MAP"][pos] = ord("X")
 461             i_trees += 1
 462     rand.seed = store_seed
 463     # This all-too-precise replica of the original C code misses iter_limit().
 464
 465
 466 def update_map_memory(t):
 467     """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
 468     if not t["T_MEMMAP"]:
 469         t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 470     if not t["T_MEMDEPTHMAP"]:
 471         t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 472     for pos in range(world_db["MAP_LENGTH"] ** 2):
 473         if "v" == chr(t["fovmap"][pos]):
 474             t["T_MEMDEPTHMAP"][pos] = ord("0")
 475             if " " == chr(t["T_MEMMAP"][pos]):
 476                 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
 477             continue
 478         # TODO: Aging of MEMDEPTHMAP.
 479     for memthing in t["T_MEMTHING"]:
 480         y = world_db["Things"][memthing[0]]["T_POSY"]
 481         x = world_db["Things"][memthing[0]]["T_POSX"]
 482         if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
 483             t["T_MEMTHING"].remove(memthing)
 484     for id in world_db["Things"]:
 485         type = world_db["Things"][id]["T_TYPE"]
 486         if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
 487             y = world_db["Things"][id]["T_POSY"]
 488             x = world_db["Things"][id]["T_POSY"]
 489             if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
 490                 t["T_MEMTHING"].append((type, y, x))
 491
 492
 493 def set_world_inactive():
 494     """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
 495     server_test()
 496     if os.access(io_db["path_worldstate"], os.F_OK):
 497         os.remove(io_db["path_worldstate"])
 498     world_db["WORLD_ACTIVE"] = 0
 499
 500
 501 def integer_test(val_string, min, max):
 502     """Return val_string if possible integer >= min and <= max, else None."""
 503     try:
 504         val = int(val_string)
 505         if val < min or val > max:
 506             raise ValueError
 507         return val
 508     except ValueError:
 509         print("Ignoring: Please use integer >= " + str(min) + " and <= " +
 510               str(max) + ".")
 511         return None
 512
 513
 514 def setter(category, key, min, max):
 515     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
 516     if category is None:
 517         def f(val_string):
 518             val = integer_test(val_string, min, max)
 519             if None != val:
 520                 world_db[key] = val
 521     else:
 522         if category == "Thing":
 523             id_store = command_tid
 524             decorator = test_Thing_id
 525         elif category == "ThingType":
 526             id_store = command_ttid
 527             decorator = test_ThingType_id
 528         elif category == "ThingAction":
 529             id_store = command_taid
 530             decorator = test_ThingAction_id
 531
 532         @decorator
 533         def f(val_string):
 534             val = integer_test(val_string, min, max)
 535             if None != val:
 536                 world_db[category + "s"][id_store.id][key] = val
 537     return f
 538
 539
 540 def build_fov_map(t):
 541     """Build Thing's FOV map."""
 542     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
 543     maptype = ctypes.c_char * len(world_db["MAP"])
 544     test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
 545                                maptype.from_buffer(t["fovmap"]),
 546                                maptype.from_buffer(world_db["MAP"]))
 547     if test:
 548         raise SystemExit("Malloc error in build_fov_Map().")
 549
 550
 551 def decrement_lifepoints(t):
 552     """Decrement t's lifepoints by 1, and if to zero, corpse it.
 553
 554     If t is the player avatar, only blank its fovmap, so that the client may
 555     still display memory data. On non-player things, erase fovmap and memory.
 556     """
 557     t["T_LIFEPOINTS"] -= 1
 558     if 0 == t["T_LIFEPOINTS"]:
 559         t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
 560         if world_db["Things"][0] == t:
 561             t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
 562             strong_write(io_db["file_out"], "LOG You die.\n")
 563         else:
 564             t["fovmap"] = False
 565             t["T_MEMMAP"] = False
 566             t["T_MEMDEPTHMAP"] = False
 567             t["T_MEMTHING"] = []
 568             strong_write(io_db["file_out"], "LOG It dies.\n")
 569
 570
 571 def mv_yx_in_dir_legal(dir, y, x):
 572     """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
 573     dir_c = dir.encode("ascii")[0]
 574     test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
 575     if -1 == test:
 576         raise SystemExit("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
 577     return (test, libpr.result_y(), libpr.result_x())
 578
 579
 580 def actor_wait(t):
 581     """Make t do nothing (but loudly, if player avatar)."""
 582     if t == world_db["Things"][0]:
 583         strong_write(io_db["file_out"], "LOG You wait.\n")
 584
 585
 586 def actor_move(t):
 587     """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
 588     passable = False
 589     move_result = mv_yx_in_dir_legal(t["T_ARGUMENT"], t["T_POSY"], t["T_POSX"])
 590     if 1 == move_result[0]:
 591         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
 592         passable = "." == chr(world_db["MAP"][pos])
 593         hitted = [id for id in world_db["Things"]
 594                   if world_db["Things"][id] != t
 595                   if world_db["Things"][id]["T_LIFEPOINTS"]
 596                   if world_db["Things"][id]["T_POSY"] == move_result[1]
 597                   if world_db["Things"][id]["T_POSX"] == move_result[2]]
 598         if len(hitted):
 599             hit_id = hitted[0]
 600             hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
 601             hitter = "You" if t == world_db["Things"][0] else hitter_name
 602             hitted_type = world_db["Things"][hit_id]["T_TYPE"]
 603             hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
 604             hitted = "you" if hit_id == 0 else hitted_name
 605             verb = " wound " if hitter == "You" else " wounds "
 606             strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted + \
 607                                             ".\n")
 608             decrement_lifepoints(world_db["Things"][hit_id])
 609             return
 610     dir = [dir for dir in directions_db
 611            if directions_db[dir] == t["T_ARGUMENT"]][0]
 612     if passable:
 613         t["T_POSY"] = move_result[1]
 614         t["T_POSX"] = move_result[2]
 615         for id in t["T_CARRIES"]:
 616             world_db["Things"][id]["T_POSY"] = move_result[1]
 617             world_db["Things"][id]["T_POSX"] = move_result[2]
 618         build_fov_map(t)
 619         strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
 620     else:
 621         strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
 622
 623
 624 def actor_pick_up(t):
 625     """Make t pick up (topmost?) Thing from ground into inventory."""
 626     # Topmostness is actually not defined so far.
 627     ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
 628            if not world_db["Things"][id]["carried"]
 629            if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
 630            if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
 631     if len(ids):
 632         world_db["Things"][ids[0]]["carried"] = True
 633         t["T_CARRIES"].append(ids[0])
 634         if t == world_db["Things"][0]:
 635             strong_write(io_db["file_out"], "LOG You pick up an object.\n")
 636     elif t == world_db["Things"][0]:
 637         err = "You try to pick up an object, but there is none."
 638         strong_write(io_db["file_out"], "LOG " + err + "\n")
 639
 640
 641 def actor_drop(t):
 642     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
 643     # TODO: Handle case where T_ARGUMENT matches nothing.
 644     if len(t["T_CARRIES"]):
 645         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 646         t["T_CARRIES"].remove(id)
 647         world_db["Things"][id]["carried"] = False
 648         if t == world_db["Things"][0]:
 649             strong_write(io_db["file_out"], "LOG You drop an object.\n")
 650     elif t == world_db["Things"][0]:
 651         err = "You try to drop an object, but you own none."
 652         strong_write(io_db["file_out"], "LOG " + err + "\n")
 653
 654
 655 def actor_use(t):
 656     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
 657     # Original wrongly featured lifepoints increase through consumable!
 658     # TODO: Handle case where T_ARGUMENT matches nothing.
 659     if len(t["T_CARRIES"]):
 660         id = t["T_CARRIES"][t["T_ARGUMENT"]]
 661         type = world_db["Things"][id]["T_TYPE"]
 662         if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
 663             t["T_CARRIES"].remove(id)
 664             del world_db["Things"][id]
 665             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
 666             strong_write(io_db["file_out"], "LOG You consume this object.\n")
 667         else:
 668             strong_write(io_db["file_out"], "LOG You try to use this object," +
 669                                             "but fail.\n")
 670     else:
 671         strong_write(io_db["file_out"], "LOG You try to use an object, but " +
 672                                         "you own none.\n")
 673
 674
 675 def turn_over():
 676     """Run game world and its inhabitants until new player input expected."""
 677     id = 0
 678     whilebreaker = False
 679     while world_db["Things"][0]["T_LIFEPOINTS"]:
 680         for id in [id for id in world_db["Things"]
 681                    if world_db["Things"][id]["T_LIFEPOINTS"]]:
 682             Thing = world_db["Things"][id]
 683             if Thing["T_LIFEPOINTS"]:
 684                 if not Thing["T_COMMAND"]:
 685                     update_map_memory(Thing)
 686                     if 0 == id:
 687                         whilebreaker = True
 688                         break
 689                     # DUMMY: ai(thing)
 690                     Thing["T_COMMAND"] = 1
 691                 # DUMMY: try_healing
 692                 Thing["T_PROGRESS"] += 1
 693                 taid = [a for a in world_db["ThingActions"]
 694                           if a == Thing["T_COMMAND"]][0]
 695                 ThingAction = world_db["ThingActions"][taid]
 696                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
 697                     eval("actor_" + ThingAction["TA_NAME"])(Thing)
 698                     Thing["T_COMMAND"] = 0
 699                     Thing["T_PROGRESS"] = 0
 700                 # DUMMY: hunger
 701             # DUMMY: thingproliferation
 702         if whilebreaker:
 703             break
 704         world_db["TURN"] += 1
 705
 706
 707 def new_Thing(type, pos=(0,0)):
 708     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
 709     thing = {
 710         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
 711         "T_ARGUMENT": 0,
 712         "T_PROGRESS": 0,
 713         "T_SATIATION": 0,
 714         "T_COMMAND": 0,
 715         "T_TYPE": type,
 716         "T_POSY": pos[0],
 717         "T_POSX": pos[1],
 718         "T_CARRIES": [],
 719         "carried": False,
 720         "T_MEMTHING": [],
 721         "T_MEMMAP": False,
 722         "T_MEMDEPTHMAP": False,
 723         "fovmap": False
 724     }
 725     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
 726         build_fov_map(thing)
 727     return thing
 728
 729
 730 def id_setter(id, category, id_store=False, start_at_1=False):
 731     """Set ID of object of category to manipulate ID unused? Create new one.
 732
 733     The ID is stored as id_store.id (if id_store is set). If the integer of the
 734     input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
 735     32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
 736     >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
 737     new object is created, otherwise the new object's ID.
 738     """
 739     min = 0 if start_at_1 else -32768
 740     max = 255 if start_at_1 else 32767
 741     if str == type(id):
 742         id = integer_test(id, min, max)
 743     if None != id:
 744         if id in world_db[category]:
 745             if id_store:
 746                 id_store.id = id
 747             return None
 748         else:
 749             if (start_at_1 and 0 == id) \
 750                or ((not start_at_1) and (id < 0 or id > 255)):
 751                 id = -1
 752                 while 1:
 753                     id = id + 1
 754                     if id not in world_db[category]:
 755                         break
 756                 if id > 255:
 757                     print("Ignoring: "
 758                           "No unused ID available to add to ID list.")
 759                     return None
 760             if id_store:
 761                 id_store.id = id
 762     return id
 763
 764
 765 def command_ping():
 766     """Send PONG line to server output file."""
 767     strong_write(io_db["file_out"], "PONG\n")
 768
 769
 770 def command_quit():
 771     """Abort server process."""
 772     raise SystemExit("received QUIT command")
 773
 774
 775 def command_thingshere(str_y, str_x):
 776     """Write to out file list of Things known to player at coordinate y, x."""
 777     def write_thing_if_here():
 778         if y == world_db["Things"][id]["T_POSY"] \
 779            and x == world_db["Things"][id]["T_POSX"] \
 780            and not world_db["Things"][id]["carried"]:
 781             type = world_db["Things"][id]["T_TYPE"]
 782             name = world_db["ThingTypes"][type]["TT_NAME"]
 783             strong_write(io_db["file_out"], name + "\n")
 784     if world_db["WORLD_ACTIVE"]:
 785         y = integer_test(str_y, 0, 255)
 786         x = integer_test(str_x, 0, 255)
 787         length = world_db["MAP_LENGTH"]
 788         if None != y and None != x and y < length and x < length:
 789             pos = (y * world_db["MAP_LENGTH"]) + x
 790             strong_write(io_db["file_out"], "THINGS_HERE START\n")
 791             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
 792                 for id in world_db["Things"]:
 793                     write_thing_if_here()
 794             else:
 795                 for id in world_db["Things"]["T_MEMTHING"]:
 796                     write_thing_if_here()
 797             strong_write(io_db["file_out"], "THINGS_HERE END\n")
 798         else:
 799             print("Ignoring: Invalid map coordinates.")
 800     else:
 801         print("Ignoring: Command only works on existing worlds.")
 802
 803
 804 def play_commander(action, args=False):
 805     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
 806
 807     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
 808     """
 809
 810     def set_command():
 811         id = [x for x in world_db["ThingActions"]
 812                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
 813         world_db["Things"][0]["T_COMMAND"] = id
 814         turn_over()
 815
 816     def set_command_and_argument_int(str_arg):
 817         val = integer_test(str_arg, 0, 255)
 818         if None != val:
 819             world_db["Things"][0]["T_ARGUMENT"] = val
 820             set_command()
 821
 822     def set_command_and_argument_movestring(str_arg):
 823         if str_arg in directions_db:
 824             world_db["Things"][0]["T_ARGUMENT"] = directions_db[str_arg]
 825             set_command()
 826         else:
 827             print("Ignoring: Argument must be valid direction string.")
 828
 829     if action == "move":
 830         return set_command_and_argument_movestring
 831     elif args:
 832         return set_command_and_argument_int
 833     else:
 834         return set_command
 835
 836
 837 def command_seedrandomness(seed_string):
 838     """Set rand seed to int(seed_string)."""
 839     val = integer_test(seed_string, 0, 4294967295)
 840     if None != val:
 841         rand.seed = val
 842
 843
 844 def command_seedmap(seed_string):
 845     """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
 846     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
 847     remake_map()
 848
 849
 850 def command_makeworld(seed_string):
 851     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
 852
 853     Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
 854     "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
 855     TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
 856     and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
 857     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
 858     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
 859     other. Init player's memory map. Write "NEW_WORLD" line to out file.
 860     """
 861
 862     def free_pos():
 863         i = 0
 864         while 1:
 865             err = "Space to put thing on too hard to find. Map too small?"
 866             while 1:
 867                 y = rand.next() % world_db["MAP_LENGTH"]
 868                 x = rand.next() % world_db["MAP_LENGTH"]
 869                 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
 870                     break
 871                 i += 1
 872                 if i == 65535:
 873                     raise SystemExit(err)
 874             # Replica of C code, wrongly ignores animatedness of new Thing.
 875             pos_clear = (0 == len([id for id in world_db["Things"]
 876                                    if world_db["Things"][id]["T_LIFEPOINTS"]
 877                                    if world_db["Things"][id]["T_POSY"] == y
 878                                    if world_db["Things"][id]["T_POSX"] == x]))
 879             if pos_clear:
 880                 break
 881         return (y, x)
 882
 883     val = integer_test(seed_string, 0, 4294967295)
 884     if None == val:
 885         return
 886     rand.seed = val
 887     world_db["SEED_MAP"] = val
 888     player_will_be_generated = False
 889     playertype = world_db["PLAYER_TYPE"]
 890     for ThingType in world_db["ThingTypes"]:
 891         if playertype == ThingType:
 892             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
 893                 player_will_be_generated = True
 894             break
 895     if not player_will_be_generated:
 896         print("Ignoring beyond SEED_MAP: " +
 897               "No player type with start number >0 defined.")
 898         return
 899     wait_action = False
 900     for ThingAction in world_db["ThingActions"]:
 901         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
 902             wait_action = True
 903     if not wait_action:
 904         print("Ignoring beyond SEED_MAP: " +
 905               "No thing action with name 'wait' defined.")
 906         return
 907     world_db["Things"] = {}
 908     remake_map()
 909     world_db["WORLD_ACTIVE"] = 1
 910     world_db["TURN"] = 1
 911     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
 912         id = id_setter(-1, "Things")
 913         world_db["Things"][id] = new_Thing(playertype, free_pos())
 914     update_map_memory(world_db["Things"][0])
 915     for type in world_db["ThingTypes"]:
 916         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
 917             if type != playertype:
 918                 id = id_setter(-1, "Things")
 919                 world_db["Things"][id] = new_Thing(type, free_pos())
 920     strong_write(io_db["file_out"], "NEW_WORLD\n")
 921
 922
 923 def command_maplength(maplength_string):
 924     """Redefine map length. Invalidate map, therefore lose all things on it."""
 925     val = integer_test(maplength_string, 1, 256)
 926     if None != val:
 927         world_db["MAP_LENGTH"] = val
 928         set_world_inactive()
 929         world_db["Things"] = {}
 930         libpr.set_maplength(val)
 931
 932
 933 def command_worldactive(worldactive_string):
 934     """Toggle world_db["WORLD_ACTIVE"] if possible.
 935
 936     An active world can always be set inactive. An inactive world can only be
 937     set active with a "wait" ThingAction, and a player Thing (of ID 0). On
 938     activation, rebuild all Things' FOVs, and the player's map memory.
 939     """
 940     # In original version, map existence was also tested (unnecessarily?).
 941     val = integer_test(worldactive_string, 0, 1)
 942     if val:
 943         if 0 != world_db["WORLD_ACTIVE"]:
 944             if 0 == val:
 945                 set_world_inactive()
 946             else:
 947                 print("World already active.")
 948         elif 0 == world_db["WORLD_ACTIVE"]:
 949             wait_exists = False
 950             for ThingAction in world_db["ThingActions"]:
 951                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
 952                     wait_exists = True
 953                     break
 954             player_exists = False
 955             for Thing in world_db["Things"]:
 956                 if 0 == Thing:
 957                     player_exists = True
 958                     break
 959             if wait_exists and player_exists:
 960                 for id in world_db["Things"]:
 961                     if world_db["Things"][id]["T_LIFEPOINTS"]:
 962                         build_fov_map(world_db["Things"][id])
 963                         if 0 == id:
 964                             update_map_memory(world_db["Things"][id])
 965                 world_db["WORLD_ACTIVE"] = 1
 966
 967
 968 def test_for_id_maker(object, category):
 969     """Return decorator testing for object having "id" attribute."""
 970     def decorator(f):
 971         def helper(*args):
 972             if hasattr(object, "id"):
 973                 f(*args)
 974             else:
 975                 print("Ignoring: No " + category +
 976                       " defined to manipulate yet.")
 977         return helper
 978     return decorator
 979
 980
 981 def command_tid(id_string):
 982     """Set ID of Thing to manipulate. ID unused? Create new one.
 983
 984     Default new Thing's type to the first available ThingType, others: zero.
 985     """
 986     id = id_setter(id_string, "Things", command_tid)
 987     if None != id:
 988         if world_db["ThingTypes"] == {}:
 989             print("Ignoring: No ThingType to settle new Thing in.")
 990             return
 991         type = list(world_db["ThingTypes"].keys())[0]
 992         world_db["Things"][id] = new_Thing(type)
 993
 994
 995 test_Thing_id = test_for_id_maker(command_tid, "Thing")
 996
 997
 998 @test_Thing_id
 999 def command_tcommand(str_int):
1000     """Set T_COMMAND of selected Thing."""
1001     val = integer_test(str_int, 0, 255)
1002     if None != val:
1003         if 0 == val or val in world_db["ThingActions"]:
1004             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1005         else:
1006             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1007
1008
1009 @test_Thing_id
1010 def command_ttype(str_int):
1011     """Set T_TYPE of selected Thing."""
1012     val = integer_test(str_int, 0, 255)
1013     if None != val:
1014         if val in world_db["ThingTypes"]:
1015             world_db["Things"][command_tid.id]["T_TYPE"] = val
1016         else:
1017             print("Ignoring: ThingType ID belongs to no known ThingType.")
1018
1019
1020 @test_Thing_id
1021 def command_tcarries(str_int):
1022     """Append int(str_int) to T_CARRIES of selected Thing.
1023
1024     The ID int(str_int) must not be of the selected Thing, and must belong to a
1025     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1026     """
1027     val = integer_test(str_int, 0, 255)
1028     if None != val:
1029         if val == command_tid.id:
1030             print("Ignoring: Thing cannot carry itself.")
1031         elif val in world_db["Things"] \
1032              and not world_db["Things"][val]["carried"]:
1033             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1034             world_db["Things"][val]["carried"] = True
1035         else:
1036             print("Ignoring: Thing not available for carrying.")
1037     # Note that the whole carrying structure is different from the C version:
1038     # Carried-ness is marked by a "carried" flag, not by Things containing
1039     # Things internally.
1040
1041
1042 @test_Thing_id
1043 def command_tmemthing(str_t, str_y, str_x):
1044     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1045
1046     The type must fit to an existing ThingType, and the position into the map.
1047     """
1048     type = integer_test(str_t, 0, 255)
1049     posy = integer_test(str_y, 0, 255)
1050     posx = integer_test(str_x, 0, 255)
1051     if None != type and None != posy and None != posx:
1052         if type not in world_db["ThingTypes"] \
1053            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1054             print("Ignoring: Illegal value for thing type or position.")
1055         else:
1056             memthing = (type, posy, posx)
1057             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1058
1059
1060 def setter_map(maptype):
1061     """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1062
1063     If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1064     """
1065     @test_Thing_id
1066     def helper(str_int, mapline):
1067         val = integer_test(str_int, 0, 255)
1068         if None != val:
1069             if val >= world_db["MAP_LENGTH"]:
1070                 print("Illegal value for map line number.")
1071             elif len(mapline) != world_db["MAP_LENGTH"]:
1072                 print("Map line length is unequal map width.")
1073             else:
1074                 length = world_db["MAP_LENGTH"]
1075                 map = None
1076                 if not world_db["Things"][command_tid.id][maptype]:
1077                     map = bytearray(b' ' * (length ** 2))
1078                 else:
1079                     map = world_db["Things"][command_tid.id][maptype]
1080                 map[val * length:(val * length) + length] = mapline.encode()
1081                 world_db["Things"][command_tid.id][maptype] = map
1082     return helper
1083
1084
1085 def setter_tpos(axis):
1086     """Generate setter for T_POSX or  T_POSY of selected Thing.
1087
1088     If world is active, rebuilds animate things' fovmap, player's memory map.
1089     """
1090     @test_Thing_id
1091     def helper(str_int):
1092         val = integer_test(str_int, 0, 255)
1093         if None != val:
1094             if val < world_db["MAP_LENGTH"]:
1095                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1096                 if world_db["WORLD_ACTIVE"] \
1097                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1098                     build_fov_map(world_db["Things"][command_tid.id])
1099                     if 0 == command_tid.id:
1100                         update_map_memory(world_db["Things"][command_tid.id])
1101             else:
1102                 print("Ignoring: Position is outside of map.")
1103     return helper
1104
1105
1106 def command_ttid(id_string):
1107     """Set ID of ThingType to manipulate. ID unused? Create new one.
1108
1109     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1110     """
1111     id = id_setter(id_string, "ThingTypes", command_ttid)
1112     if None != id:
1113         world_db["ThingTypes"][id] = {
1114             "TT_NAME": "(none)",
1115             "TT_CONSUMABLE": 0,
1116             "TT_LIFEPOINTS": 0,
1117             "TT_PROLIFERATE": 0,
1118             "TT_START_NUMBER": 0,
1119             "TT_SYMBOL": "?",
1120             "TT_CORPSE_ID": id
1121         }
1122
1123
1124 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1125
1126
1127 @test_ThingType_id
1128 def command_ttname(name):
1129     """Set TT_NAME of selected ThingType."""
1130     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1131
1132
1133 @test_ThingType_id
1134 def command_ttsymbol(char):
1135     """Set TT_SYMBOL of selected ThingType. """
1136     if 1 == len(char):
1137         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1138     else:
1139         print("Ignoring: Argument must be single character.")
1140
1141
1142 @test_ThingType_id
1143 def command_ttcorpseid(str_int):
1144     """Set TT_CORPSE_ID of selected ThingType."""
1145     val = integer_test(str_int, 0, 255)
1146     if None != val:
1147         if val in world_db["ThingTypes"]:
1148             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1149         else:
1150             print("Ignoring: Corpse ID belongs to no known ThignType.")
1151
1152
1153 def command_taid(id_string):
1154     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1155
1156     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1157     """
1158     id = id_setter(id_string, "ThingActions", command_taid, True)
1159     if None != id:
1160         world_db["ThingActions"][id] = {
1161             "TA_EFFORT": 1,
1162             "TA_NAME": "wait"
1163         }
1164
1165
1166 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1167
1168
1169 @test_ThingAction_id
1170 def command_taname(name):
1171     """Set TA_NAME of selected ThingAction.
1172
1173     The name must match a valid thing action function. If after the name
1174     setting no ThingAction with name "wait" remains, call set_world_inactive().
1175     """
1176     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1177        or name == "pick_up":
1178         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1179         if 1 == world_db["WORLD_ACTIVE"]:
1180             wait_defined = False
1181             for id in world_db["ThingActions"]:
1182                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1183                     wait_defined = True
1184                     break
1185             if not wait_defined:
1186                 set_world_inactive()
1187     else:
1188         print("Ignoring: Invalid action name.")
1189     # In contrast to the original,naming won't map a function to a ThingAction.
1190
1191
1192 """Commands database.
1193
1194 Map command start tokens to ([0]) number of expected command arguments, ([1])
1195 the command's meta-ness (i.e. is it to be written to the record file, is it to
1196 be ignored in replay mode if read from server input file), and ([2]) a function
1197 to be called on it.
1198 """
1199 commands_db = {
1200     "QUIT": (0, True, command_quit),
1201     "PING": (0, True, command_ping),
1202     "THINGS_HERE": (2, True, command_thingshere),
1203     "MAKE_WORLD": (1, False, command_makeworld),
1204     "SEED_MAP": (1, False, command_seedmap),
1205     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1206     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1207     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1208     "MAP_LENGTH": (1, False, command_maplength),
1209     "WORLD_ACTIVE": (1, False, command_worldactive),
1210     "TA_ID": (1, False, command_taid),
1211     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1212     "TA_NAME": (1, False, command_taname),
1213     "TT_ID": (1, False, command_ttid),
1214     "TT_NAME": (1, False, command_ttname),
1215     "TT_SYMBOL": (1, False, command_ttsymbol),
1216     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1217     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1218                                        0, 65535)),
1219     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1220                                          0, 255)),
1221     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1222                                         0, 255)),
1223     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1224     "T_ID": (1, False, command_tid),
1225     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1226     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1227     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1228     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1229     "T_COMMAND": (1, False, command_tcommand),
1230     "T_TYPE": (1, False, command_ttype),
1231     "T_CARRIES": (1, False, command_tcarries),
1232     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1233     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1234     "T_MEMTHING": (3, False, command_tmemthing),
1235     "T_POSY": (1, False, setter_tpos("Y")),
1236     "T_POSX": (1, False, setter_tpos("X")),
1237     "wait": (0, False, play_commander("wait")),
1238     "move": (1, False, play_commander("move")),
1239     "pick_up": (0, False, play_commander("pick_up")),
1240     "drop": (1, False, play_commander("drop", True)),
1241     "use": (1, False, play_commander("use", True)),
1242 }
1243
1244
1245 """World state database. With sane default values. (Randomness is in rand.)"""
1246 world_db = {
1247     "TURN": 0,
1248     "SEED_MAP": 0,
1249     "PLAYER_TYPE": 0,
1250     "MAP_LENGTH": 64,
1251     "WORLD_ACTIVE": 0,
1252     "ThingActions": {},
1253     "ThingTypes": {},
1254     "Things": {}
1255 }
1256
1257 """Mapping of direction names to internal direction chars."""
1258 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1259                  "west": "s", "north-west": "w", "north-east": "e"}
1260
1261 """File IO database."""
1262 io_db = {
1263     "path_save": "save",
1264     "path_record": "record",
1265     "path_worldconf": "confserver/world",
1266     "path_server": "server/",
1267     "path_in": "server/in",
1268     "path_out": "server/out",
1269     "path_worldstate": "server/worldstate",
1270     "tmp_suffix": "_tmp",
1271     "kicked_by_rival": False,
1272     "worldstate_updateable": False
1273 }
1274
1275
1276 try:
1277     libpr = prep_library()
1278     rand = RandomnessIO()
1279     opts = parse_command_line_arguments()
1280     setup_server_io()
1281     if None != opts.replay:
1282         replay_game()
1283     else:
1284         play_game()
1285 except SystemExit as exit:
1286     print("ABORTING: " + exit.args[0])
1287 except:
1288     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1289     raise
1290 finally:
1291     cleanup_server_io()