11 """"Interface to libplomrogue's pseudo-randomness generator."""
13 def set_seed(self, seed):
14 libpr.seed_rrand(1, seed)
17 return libpr.seed_rrand(0, 0)
22 seed = property(get_seed, set_seed)
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,
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
48 def strong_write(file, string):
49 """Apply write(string), flush(), and os.fsync() to file."""
55 def setup_server_io():
56 """Fill IO files DB with proper file( path)s. Write process IO test string.
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"].
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):
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"])
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):
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()
99 def obey(command, prefix, replay=False, do_record=False):
100 """Call function from commands_db mapped to command's first token.
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.
111 print("input " + prefix + ": " + command)
113 tokens = shlex.split(command, comments=True)
114 except ValueError as err:
115 print("Can't tokenize command string: " + str(err) + ".")
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:])
122 print("Due to replay mode, reading command as 'go on in record'.")
123 line = io_db["file_record"].readline()
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
129 print("Reached end of record file.")
131 commands_db[tokens[0]][2](*tokens[1:])
135 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
136 elif 0 != len(tokens):
137 print("Invalid command/argument, or bad number of tokens.")
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"]
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)
151 if os.access(path, os.F_OK):
153 os.rename(path_tmp, path)
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)
165 """Save all commands needed to reconstruct current world state."""
166 # TODO: Misses same optimizations as record() from the original record().
169 string = string.replace("\u005C", '\u005C\u005C')
170 return '"' + string.replace('"', '\u005C"') + '"'
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) \
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"
192 def helper(category, id_string, special_keys={}):
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)
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)
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")
233 for line in file.readlines():
234 obey(line.rstrip(), name + "file line " + str(line_n),
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,
245 opts, unknown = parser.parse_known_args()
250 """Ensure valid server out file belonging to current process.
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.
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")
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)
270 """Return next newline-delimited command from server in file.
272 Keep building return string until a newline is encountered. Pause between
273 unsuccessful reads, and after too much waiting, run server_test().
275 wait_on_fail = 0.03333
280 add = io_db["file_in"].readline()
282 command = command + add
283 if len(command) > 0 and "\n" == command[-1]:
284 command = command[:-1]
287 time.sleep(wait_on_fail)
288 if now + max_wait < time.time():
294 def try_worldstate_update():
295 """Write worldstate file if io_db["worldstate_updateable"] is set."""
296 if io_db["worldstate_updateable"]:
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)
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"
320 if [] == world_db["Things"][0]["T_CARRIES"]:
321 inventory = "(none)\n"
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]
340 draw_visible_Things(fov, i)
341 string = write_map(string, fov)
342 mem = world_db["Things"][0]["T_MEMMAP"][:]
344 for mt in world_db["Things"][0]["T_MEMTHING"]:
345 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
346 if (i == 0 and not consumable) or (i == 1 and consumable):
347 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
348 mem[(mt[1] * length) + mt[2]] = ord(c)
349 string = write_map(string, mem)
350 atomic_write(io_db["path_worldstate"], string)
351 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
352 io_db["worldstate_updateable"] = False
356 """Replay game from record file.
358 Use opts.replay as breakpoint turn to which to replay automatically before
359 switching to manual input by non-meta commands in server input file
360 triggering further reads of record file. Ensure opts.replay is at least 1.
361 Run try_worldstate_update() before each interactive obey()/read_command().
365 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
366 " (if so late a turn is to be found).")
367 if not os.access(io_db["path_record"], os.F_OK):
368 raise SystemExit("No record file found to replay.")
369 io_db["file_record"] = open(io_db["path_record"], "r")
370 io_db["file_record"].prefix = "record file line "
371 io_db["file_record"].line_n = 1
372 while world_db["TURN"] < opts.replay:
373 line = io_db["file_record"].readline()
376 obey(line.rstrip(), io_db["file_record"].prefix
377 + str(io_db["file_record"].line_n))
378 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
380 try_worldstate_update()
381 obey(read_command(), "in file", replay=True)
385 """Play game by server input file commands. Before, load save file found.
387 If no save file is found, a new world is generated from the commands in the
388 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
389 command and all that follow via the server input file. Run
390 try_worldstate_update() before each interactive obey()/read_command().
392 if os.access(io_db["path_save"], os.F_OK):
393 obey_lines_in_file(io_db["path_save"], "save")
395 if not os.access(io_db["path_worldconf"], os.F_OK):
396 msg = "No world config file from which to start a new world."
397 raise SystemExit(msg)
398 obey_lines_in_file(io_db["path_worldconf"], "world config ",
400 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
402 try_worldstate_update()
403 obey(read_command(), "in file", do_record=True)
407 """(Re-)make island map.
409 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
410 start with one land cell in the middle, then go into cycle of repeatedly
411 selecting a random sea cell and transforming it into land if it is neighbor
412 to land. The cycle ends when a land cell is due to be created at the map's
413 border. Then put some trees on the map (TODO: more precise algorithm desc).
415 def is_neighbor(coordinates, type):
418 length = world_db["MAP_LENGTH"]
420 diag_west = x + (ind > 0)
421 diag_east = x + (ind < (length - 1))
422 pos = (y * length) + x
423 if (y > 0 and diag_east
424 and type == chr(world_db["MAP"][pos - length + ind])) \
426 and type == chr(world_db["MAP"][pos + 1])) \
427 or (y < (length - 1) and diag_east
428 and type == chr(world_db["MAP"][pos + length + ind])) \
429 or (y > 0 and diag_west
430 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
432 and type == chr(world_db["MAP"][pos - 1])) \
433 or (y < (length - 1) and diag_west
434 and type == chr(world_db["MAP"][pos + length - (not ind)])):
437 store_seed = rand.seed
438 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
439 length = world_db["MAP_LENGTH"]
440 add_half_width = (not (length % 2)) * int(length / 2)
441 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
443 y = rand.next() % length
444 x = rand.next() % length
445 pos = (y * length) + x
446 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
447 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
449 world_db["MAP"][pos] = ord(".")
450 n_trees = int((length ** 2) / 16)
452 while (i_trees <= n_trees):
453 single_allowed = rand.next() % 32
454 y = rand.next() % length
455 x = rand.next() % length
456 pos = (y * length) + x
457 if "." == chr(world_db["MAP"][pos]) \
458 and ((not single_allowed) or is_neighbor((y, x), "X")):
459 world_db["MAP"][pos] = ord("X")
461 rand.seed = store_seed
462 # This all-too-precise replica of the original C code misses iter_limit().
465 def update_map_memory(t):
466 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
467 if not t["T_MEMMAP"]:
468 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
469 if not t["T_MEMDEPTHMAP"]:
470 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
471 for pos in range(world_db["MAP_LENGTH"] ** 2):
472 if "v" == chr(t["fovmap"][pos]):
473 t["T_MEMDEPTHMAP"][pos] = ord("0")
474 if " " == chr(t["T_MEMMAP"][pos]):
475 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
477 if ord('0') <= t["T_MEMDEPTHMAP"][pos] \
478 and ord('9') >= t["T_MEMDEPTHMAP"][pos] \
479 and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)):
480 t["T_MEMDEPTHMAP"][pos] += 1
481 for mt in [mt for mt in t["T_MEMTHING"]
482 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
484 t["T_MEMTHING"].remove(mt)
485 for id in world_db["Things"]:
486 type = world_db["Things"][id]["T_TYPE"]
487 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
488 y = world_db["Things"][id]["T_POSY"]
489 x = world_db["Things"][id]["T_POSX"]
490 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
491 t["T_MEMTHING"].append((type, y, x))
494 def set_world_inactive():
495 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
497 if os.access(io_db["path_worldstate"], os.F_OK):
498 os.remove(io_db["path_worldstate"])
499 world_db["WORLD_ACTIVE"] = 0
502 def integer_test(val_string, min, max):
503 """Return val_string if possible integer >= min and <= max, else None."""
505 val = int(val_string)
506 if val < min or val > max:
510 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
515 def setter(category, key, min, max):
516 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
519 val = integer_test(val_string, min, max)
523 if category == "Thing":
524 id_store = command_tid
525 decorator = test_Thing_id
526 elif category == "ThingType":
527 id_store = command_ttid
528 decorator = test_ThingType_id
529 elif category == "ThingAction":
530 id_store = command_taid
531 decorator = test_ThingAction_id
535 val = integer_test(val_string, min, max)
537 world_db[category + "s"][id_store.id][key] = val
541 def build_fov_map(t):
542 """Build Thing's FOV map."""
543 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
544 maptype = ctypes.c_char * len(world_db["MAP"])
545 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
546 maptype.from_buffer(t["fovmap"]),
547 maptype.from_buffer(world_db["MAP"]))
549 raise RuntimeError("Malloc error in build_fov_Map().")
552 def decrement_lifepoints(t):
553 """Decrement t's lifepoints by 1, and if to zero, corpse it.
555 If t is the player avatar, only blank its fovmap, so that the client may
556 still display memory data. On non-player things, erase fovmap and memory.
558 t["T_LIFEPOINTS"] -= 1
559 if 0 == t["T_LIFEPOINTS"]:
560 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
561 if world_db["Things"][0] == t:
562 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
563 strong_write(io_db["file_out"], "LOG You die.\n")
566 t["T_MEMMAP"] = False
567 t["T_MEMDEPTHMAP"] = False
569 strong_write(io_db["file_out"], "LOG It dies.\n")
572 def mv_yx_in_dir_legal(dir, y, x):
573 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
574 dir_c = dir.encode("ascii")[0]
575 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
577 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
578 return (test, libpr.result_y(), libpr.result_x())
582 """Make t do nothing (but loudly, if player avatar)."""
583 if t == world_db["Things"][0]:
584 strong_write(io_db["file_out"], "LOG You wait.\n")
588 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
590 move_result = mv_yx_in_dir_legal(t["T_ARGUMENT"], t["T_POSY"], t["T_POSX"])
591 if 1 == move_result[0]:
592 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
593 passable = "." == chr(world_db["MAP"][pos])
594 hitted = [id for id in world_db["Things"]
595 if world_db["Things"][id] != t
596 if world_db["Things"][id]["T_LIFEPOINTS"]
597 if world_db["Things"][id]["T_POSY"] == move_result[1]
598 if world_db["Things"][id]["T_POSX"] == move_result[2]]
601 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
602 hitter = "You" if t == world_db["Things"][0] else hitter_name
603 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
604 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
605 hitted = "you" if hit_id == 0 else hitted_name
606 verb = " wound " if hitter == "You" else " wounds "
607 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
609 decrement_lifepoints(world_db["Things"][hit_id])
611 dir = [dir for dir in directions_db
612 if directions_db[dir] == t["T_ARGUMENT"]][0]
614 t["T_POSY"] = move_result[1]
615 t["T_POSX"] = move_result[2]
616 for id in t["T_CARRIES"]:
617 world_db["Things"][id]["T_POSY"] = move_result[1]
618 world_db["Things"][id]["T_POSX"] = move_result[2]
620 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
622 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
625 def actor_pick_up(t):
626 """Make t pick up (topmost?) Thing from ground into inventory."""
627 # Topmostness is actually not defined so far.
628 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
629 if not world_db["Things"][id]["carried"]
630 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
631 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
633 world_db["Things"][ids[0]]["carried"] = True
634 t["T_CARRIES"].append(ids[0])
635 if t == world_db["Things"][0]:
636 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
637 elif t == world_db["Things"][0]:
638 err = "You try to pick up an object, but there is none."
639 strong_write(io_db["file_out"], "LOG " + err + "\n")
643 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
644 # TODO: Handle case where T_ARGUMENT matches nothing.
645 if len(t["T_CARRIES"]):
646 id = t["T_CARRIES"][t["T_ARGUMENT"]]
647 t["T_CARRIES"].remove(id)
648 world_db["Things"][id]["carried"] = False
649 if t == world_db["Things"][0]:
650 strong_write(io_db["file_out"], "LOG You drop an object.\n")
651 elif t == world_db["Things"][0]:
652 err = "You try to drop an object, but you own none."
653 strong_write(io_db["file_out"], "LOG " + err + "\n")
657 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
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 t["T_LIFEPOINTS"] += 1
667 # Wrongly increment HPs is a replica of the original code.
668 strong_write(io_db["file_out"], "LOG You consume this object.\n")
670 strong_write(io_db["file_out"], "LOG You try to use this object," +
673 strong_write(io_db["file_out"], "LOG You try to use an object, but " +
677 def thingproliferation(t):
678 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
680 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
681 passable and not be inhabited by a Thing of the same type, or, if Thing is
682 animate, any other animate Thing. If there are several map cell candidates,
683 one is selected randomly.
685 def test_cell(t, y, x):
686 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
687 for id in [id for id in world_db["Things"]
688 if y == world_db["Things"][id]["T_POSY"]
689 if x == world_db["Things"][id]["T_POSX"]
690 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
691 or (t["T_LIFEPOINTS"] and
692 world_db["Things"][id]["T_LIFEPOINTS"])]:
696 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
697 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
699 for dir in [directions_db[key] for key in directions_db]:
700 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
701 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
702 candidates.append((mv_result[1], mv_result[2]))
704 i = rand.next() % len(candidates)
705 id = id_setter(-1, "Things")
706 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
707 world_db["Things"][id] = newT
711 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
713 On success, decrease satiation score by 32.
715 if t["T_SATIATION"] > 0 \
716 and t["T_LIFEPOINTS"] < \
717 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
718 and 0 == (rand.next() % 31) \
719 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
720 if world_db["ThingActions"][id]["TA_NAME"] ==
722 t["T_LIFEPOINTS"] += 1
723 t["T_SATIATION"] -= 32
724 if t == world_db["Things"][0]:
725 strong_write(io_db["file_out"], "LOG You heal.\n")
727 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
728 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
732 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
733 if t["T_SATIATION"] > -32768:
734 t["T_SATIATION"] -= 1
735 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
736 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
737 raise RuntimeError("A thing that should not hunger is hungering.")
738 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
739 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
740 if t == world_db["Things"][0]:
741 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
743 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
744 strong_write(io_db["file_out"], "LOG " + name +
745 " suffers from hunger.\n")
746 decrement_lifepoints(t)
750 """Run game world and its inhabitants until new player input expected."""
753 while world_db["Things"][0]["T_LIFEPOINTS"]:
754 for id in [id for id in world_db["Things"]]:
755 Thing = world_db["Things"][id]
756 if Thing["T_LIFEPOINTS"]:
757 if not Thing["T_COMMAND"]:
758 update_map_memory(Thing)
763 Thing["T_COMMAND"] = 1
765 Thing["T_PROGRESS"] += 1
766 taid = [a for a in world_db["ThingActions"]
767 if a == Thing["T_COMMAND"]][0]
768 ThingAction = world_db["ThingActions"][taid]
769 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
770 eval("actor_" + ThingAction["TA_NAME"])(Thing)
771 Thing["T_COMMAND"] = 0
772 Thing["T_PROGRESS"] = 0
774 thingproliferation(Thing)
777 world_db["TURN"] += 1
780 def new_Thing(type, pos=(0, 0)):
781 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
783 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
795 "T_MEMDEPTHMAP": False,
798 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
803 def id_setter(id, category, id_store=False, start_at_1=False):
804 """Set ID of object of category to manipulate ID unused? Create new one.
806 The ID is stored as id_store.id (if id_store is set). If the integer of the
807 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
808 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
809 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
810 new object is created, otherwise the new object's ID.
812 min = 0 if start_at_1 else -32768
813 max = 255 if start_at_1 else 32767
815 id = integer_test(id, min, max)
817 if id in world_db[category]:
822 if (start_at_1 and 0 == id) \
823 or ((not start_at_1) and (id < 0 or id > 255)):
827 if id not in world_db[category]:
831 "No unused ID available to add to ID list.")
839 """Send PONG line to server output file."""
840 strong_write(io_db["file_out"], "PONG\n")
844 """Abort server process."""
845 raise SystemExit("received QUIT command")
848 def command_thingshere(str_y, str_x):
849 """Write to out file list of Things known to player at coordinate y, x."""
850 def write_thing_if_here():
851 if y == world_db["Things"][id]["T_POSY"] \
852 and x == world_db["Things"][id]["T_POSX"] \
853 and not world_db["Things"][id]["carried"]:
854 type = world_db["Things"][id]["T_TYPE"]
855 name = world_db["ThingTypes"][type]["TT_NAME"]
856 strong_write(io_db["file_out"], name + "\n")
857 if world_db["WORLD_ACTIVE"]:
858 y = integer_test(str_y, 0, 255)
859 x = integer_test(str_x, 0, 255)
860 length = world_db["MAP_LENGTH"]
861 if None != y and None != x and y < length and x < length:
862 pos = (y * world_db["MAP_LENGTH"]) + x
863 strong_write(io_db["file_out"], "THINGS_HERE START\n")
864 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
865 for id in world_db["Things"]:
866 write_thing_if_here()
868 for id in world_db["Things"][0]["T_MEMTHING"]:
869 write_thing_if_here()
870 strong_write(io_db["file_out"], "THINGS_HERE END\n")
872 print("Ignoring: Invalid map coordinates.")
874 print("Ignoring: Command only works on existing worlds.")
877 def play_commander(action, args=False):
878 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
880 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
884 id = [x for x in world_db["ThingActions"]
885 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
886 world_db["Things"][0]["T_COMMAND"] = id
889 def set_command_and_argument_int(str_arg):
890 val = integer_test(str_arg, 0, 255)
892 world_db["Things"][0]["T_ARGUMENT"] = val
895 def set_command_and_argument_movestring(str_arg):
896 if str_arg in directions_db:
897 world_db["Things"][0]["T_ARGUMENT"] = directions_db[str_arg]
900 print("Ignoring: Argument must be valid direction string.")
903 return set_command_and_argument_movestring
905 return set_command_and_argument_int
910 def command_seedrandomness(seed_string):
911 """Set rand seed to int(seed_string)."""
912 val = integer_test(seed_string, 0, 4294967295)
917 def command_seedmap(seed_string):
918 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
919 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
923 def command_makeworld(seed_string):
924 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
926 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
927 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
928 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
929 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
930 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
931 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
932 other. Init player's memory map. Write "NEW_WORLD" line to out file.
938 err = "Space to put thing on too hard to find. Map too small?"
940 y = rand.next() % world_db["MAP_LENGTH"]
941 x = rand.next() % world_db["MAP_LENGTH"]
942 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
946 raise SystemExit(err)
947 # Replica of C code, wrongly ignores animatedness of new Thing.
948 pos_clear = (0 == len([id for id in world_db["Things"]
949 if world_db["Things"][id]["T_LIFEPOINTS"]
950 if world_db["Things"][id]["T_POSY"] == y
951 if world_db["Things"][id]["T_POSX"] == x]))
956 val = integer_test(seed_string, 0, 4294967295)
960 world_db["SEED_MAP"] = val
961 player_will_be_generated = False
962 playertype = world_db["PLAYER_TYPE"]
963 for ThingType in world_db["ThingTypes"]:
964 if playertype == ThingType:
965 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
966 player_will_be_generated = True
968 if not player_will_be_generated:
969 print("Ignoring beyond SEED_MAP: " +
970 "No player type with start number >0 defined.")
973 for ThingAction in world_db["ThingActions"]:
974 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
977 print("Ignoring beyond SEED_MAP: " +
978 "No thing action with name 'wait' defined.")
980 world_db["Things"] = {}
982 world_db["WORLD_ACTIVE"] = 1
984 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
985 id = id_setter(-1, "Things")
986 world_db["Things"][id] = new_Thing(playertype, free_pos())
987 update_map_memory(world_db["Things"][0])
988 for type in world_db["ThingTypes"]:
989 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
990 if type != playertype:
991 id = id_setter(-1, "Things")
992 world_db["Things"][id] = new_Thing(type, free_pos())
993 strong_write(io_db["file_out"], "NEW_WORLD\n")
996 def command_maplength(maplength_string):
997 """Redefine map length. Invalidate map, therefore lose all things on it."""
998 val = integer_test(maplength_string, 1, 256)
1000 world_db["MAP_LENGTH"] = val
1001 set_world_inactive()
1002 world_db["Things"] = {}
1003 libpr.set_maplength(val)
1006 def command_worldactive(worldactive_string):
1007 """Toggle world_db["WORLD_ACTIVE"] if possible.
1009 An active world can always be set inactive. An inactive world can only be
1010 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1011 activation, rebuild all Things' FOVs, and the player's map memory.
1013 # In original version, map existence was also tested (unnecessarily?).
1014 val = integer_test(worldactive_string, 0, 1)
1016 if 0 != world_db["WORLD_ACTIVE"]:
1018 set_world_inactive()
1020 print("World already active.")
1021 elif 0 == world_db["WORLD_ACTIVE"]:
1023 for ThingAction in world_db["ThingActions"]:
1024 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1027 player_exists = False
1028 for Thing in world_db["Things"]:
1030 player_exists = True
1032 if wait_exists and player_exists:
1033 for id in world_db["Things"]:
1034 if world_db["Things"][id]["T_LIFEPOINTS"]:
1035 build_fov_map(world_db["Things"][id])
1037 update_map_memory(world_db["Things"][id])
1038 world_db["WORLD_ACTIVE"] = 1
1041 def test_for_id_maker(object, category):
1042 """Return decorator testing for object having "id" attribute."""
1045 if hasattr(object, "id"):
1048 print("Ignoring: No " + category +
1049 " defined to manipulate yet.")
1054 def command_tid(id_string):
1055 """Set ID of Thing to manipulate. ID unused? Create new one.
1057 Default new Thing's type to the first available ThingType, others: zero.
1059 id = id_setter(id_string, "Things", command_tid)
1061 if world_db["ThingTypes"] == {}:
1062 print("Ignoring: No ThingType to settle new Thing in.")
1064 type = list(world_db["ThingTypes"].keys())[0]
1065 world_db["Things"][id] = new_Thing(type)
1068 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1072 def command_tcommand(str_int):
1073 """Set T_COMMAND of selected Thing."""
1074 val = integer_test(str_int, 0, 255)
1076 if 0 == val or val in world_db["ThingActions"]:
1077 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1079 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1083 def command_ttype(str_int):
1084 """Set T_TYPE of selected Thing."""
1085 val = integer_test(str_int, 0, 255)
1087 if val in world_db["ThingTypes"]:
1088 world_db["Things"][command_tid.id]["T_TYPE"] = val
1090 print("Ignoring: ThingType ID belongs to no known ThingType.")
1094 def command_tcarries(str_int):
1095 """Append int(str_int) to T_CARRIES of selected Thing.
1097 The ID int(str_int) must not be of the selected Thing, and must belong to a
1098 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1100 val = integer_test(str_int, 0, 255)
1102 if val == command_tid.id:
1103 print("Ignoring: Thing cannot carry itself.")
1104 elif val in world_db["Things"] \
1105 and not world_db["Things"][val]["carried"]:
1106 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1107 world_db["Things"][val]["carried"] = True
1109 print("Ignoring: Thing not available for carrying.")
1110 # Note that the whole carrying structure is different from the C version:
1111 # Carried-ness is marked by a "carried" flag, not by Things containing
1112 # Things internally.
1116 def command_tmemthing(str_t, str_y, str_x):
1117 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1119 The type must fit to an existing ThingType, and the position into the map.
1121 type = integer_test(str_t, 0, 255)
1122 posy = integer_test(str_y, 0, 255)
1123 posx = integer_test(str_x, 0, 255)
1124 if None != type and None != posy and None != posx:
1125 if type not in world_db["ThingTypes"] \
1126 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1127 print("Ignoring: Illegal value for thing type or position.")
1129 memthing = (type, posy, posx)
1130 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1133 def setter_map(maptype):
1134 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1136 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1139 def helper(str_int, mapline):
1140 val = integer_test(str_int, 0, 255)
1142 if val >= world_db["MAP_LENGTH"]:
1143 print("Illegal value for map line number.")
1144 elif len(mapline) != world_db["MAP_LENGTH"]:
1145 print("Map line length is unequal map width.")
1147 length = world_db["MAP_LENGTH"]
1149 if not world_db["Things"][command_tid.id][maptype]:
1150 map = bytearray(b' ' * (length ** 2))
1152 map = world_db["Things"][command_tid.id][maptype]
1153 map[val * length:(val * length) + length] = mapline.encode()
1154 world_db["Things"][command_tid.id][maptype] = map
1158 def setter_tpos(axis):
1159 """Generate setter for T_POSX or T_POSY of selected Thing.
1161 If world is active, rebuilds animate things' fovmap, player's memory map.
1164 def helper(str_int):
1165 val = integer_test(str_int, 0, 255)
1167 if val < world_db["MAP_LENGTH"]:
1168 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1169 if world_db["WORLD_ACTIVE"] \
1170 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1171 build_fov_map(world_db["Things"][command_tid.id])
1172 if 0 == command_tid.id:
1173 update_map_memory(world_db["Things"][command_tid.id])
1175 print("Ignoring: Position is outside of map.")
1179 def command_ttid(id_string):
1180 """Set ID of ThingType to manipulate. ID unused? Create new one.
1182 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1184 id = id_setter(id_string, "ThingTypes", command_ttid)
1186 world_db["ThingTypes"][id] = {
1187 "TT_NAME": "(none)",
1190 "TT_PROLIFERATE": 0,
1191 "TT_START_NUMBER": 0,
1197 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1201 def command_ttname(name):
1202 """Set TT_NAME of selected ThingType."""
1203 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1207 def command_ttsymbol(char):
1208 """Set TT_SYMBOL of selected ThingType. """
1210 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1212 print("Ignoring: Argument must be single character.")
1216 def command_ttcorpseid(str_int):
1217 """Set TT_CORPSE_ID of selected ThingType."""
1218 val = integer_test(str_int, 0, 255)
1220 if val in world_db["ThingTypes"]:
1221 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1223 print("Ignoring: Corpse ID belongs to no known ThignType.")
1226 def command_taid(id_string):
1227 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1229 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1231 id = id_setter(id_string, "ThingActions", command_taid, True)
1233 world_db["ThingActions"][id] = {
1239 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1242 @test_ThingAction_id
1243 def command_taname(name):
1244 """Set TA_NAME of selected ThingAction.
1246 The name must match a valid thing action function. If after the name
1247 setting no ThingAction with name "wait" remains, call set_world_inactive().
1249 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1250 or name == "pick_up":
1251 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1252 if 1 == world_db["WORLD_ACTIVE"]:
1253 wait_defined = False
1254 for id in world_db["ThingActions"]:
1255 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1258 if not wait_defined:
1259 set_world_inactive()
1261 print("Ignoring: Invalid action name.")
1262 # In contrast to the original,naming won't map a function to a ThingAction.
1265 """Commands database.
1267 Map command start tokens to ([0]) number of expected command arguments, ([1])
1268 the command's meta-ness (i.e. is it to be written to the record file, is it to
1269 be ignored in replay mode if read from server input file), and ([2]) a function
1273 "QUIT": (0, True, command_quit),
1274 "PING": (0, True, command_ping),
1275 "THINGS_HERE": (2, True, command_thingshere),
1276 "MAKE_WORLD": (1, False, command_makeworld),
1277 "SEED_MAP": (1, False, command_seedmap),
1278 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1279 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1280 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1281 "MAP_LENGTH": (1, False, command_maplength),
1282 "WORLD_ACTIVE": (1, False, command_worldactive),
1283 "TA_ID": (1, False, command_taid),
1284 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1285 "TA_NAME": (1, False, command_taname),
1286 "TT_ID": (1, False, command_ttid),
1287 "TT_NAME": (1, False, command_ttname),
1288 "TT_SYMBOL": (1, False, command_ttsymbol),
1289 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1290 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1292 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1294 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1296 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1297 "T_ID": (1, False, command_tid),
1298 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1299 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1300 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1301 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1302 "T_COMMAND": (1, False, command_tcommand),
1303 "T_TYPE": (1, False, command_ttype),
1304 "T_CARRIES": (1, False, command_tcarries),
1305 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1306 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1307 "T_MEMTHING": (3, False, command_tmemthing),
1308 "T_POSY": (1, False, setter_tpos("Y")),
1309 "T_POSX": (1, False, setter_tpos("X")),
1310 "wait": (0, False, play_commander("wait")),
1311 "move": (1, False, play_commander("move")),
1312 "pick_up": (0, False, play_commander("pick_up")),
1313 "drop": (1, False, play_commander("drop", True)),
1314 "use": (1, False, play_commander("use", True)),
1318 """World state database. With sane default values. (Randomness is in rand.)"""
1330 """Mapping of direction names to internal direction chars."""
1331 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1332 "west": "s", "north-west": "w", "north-east": "e"}
1334 """File IO database."""
1336 "path_save": "save",
1337 "path_record": "record",
1338 "path_worldconf": "confserver/world",
1339 "path_server": "server/",
1340 "path_in": "server/in",
1341 "path_out": "server/out",
1342 "path_worldstate": "server/worldstate",
1343 "tmp_suffix": "_tmp",
1344 "kicked_by_rival": False,
1345 "worldstate_updateable": False
1350 libpr = prep_library()
1351 rand = RandomnessIO()
1352 opts = parse_command_line_arguments()
1354 if None != opts.replay:
1358 except SystemExit as exit:
1359 print("ABORTING: " + exit.args[0])
1361 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")