3 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
4 # or any later version. For details on its copyright, license, and warranties,
5 # see the file NOTICE in the root directory of the PlomRogue source package.
19 """"Interface to libplomrogue's pseudo-randomness generator."""
21 def set_seed(self, seed):
22 libpr.seed_rrand(1, seed)
25 return libpr.seed_rrand(0, 0)
30 seed = property(get_seed, set_seed)
34 """Prepare ctypes library at ./libplomrogue.so"""
35 libpath = ("./libplomrogue.so")
36 if not os.access(libpath, os.F_OK):
37 raise SystemExit("No library " + libpath + ", run ./redo first?")
38 libpr = ctypes.cdll.LoadLibrary(libpath)
39 libpr.seed_rrand.restype = ctypes.c_uint32
43 def c_pointer_to_bytearray(ba):
44 """Return C char * pointer to ba."""
45 type = ctypes.c_char * len(ba)
46 return type.from_buffer(ba)
49 def strong_write(file, string):
50 """Apply write(string), then flush()."""
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 io_db["save_wait"] = 0
73 io_db["verbose"] = False
74 io_db["record_chunk"] = ""
75 os.makedirs(io_db["path_server"], exist_ok=True)
76 io_db["file_out"] = open(io_db["path_out"], "w")
77 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
78 if os.access(io_db["path_in"], os.F_OK):
79 os.remove(io_db["path_in"])
80 io_db["file_in"] = open(io_db["path_in"], "w")
81 io_db["file_in"].close()
82 io_db["file_in"] = open(io_db["path_in"], "r")
83 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
84 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
87 def cleanup_server_io():
88 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
89 def helper(file_key, path_key):
91 io_db[file_key].close()
92 if not io_db["kicked_by_rival"] \
93 and os.access(io_db[path_key], os.F_OK):
94 os.remove(io_db[path_key])
95 helper("file_in", "path_in")
96 helper("file_out", "path_out")
97 helper("file_worldstate", "path_worldstate")
98 if "file_record" in io_db:
99 io_db["file_record"].close()
102 def obey(command, prefix, replay=False, do_record=False):
103 """Call function from commands_db mapped to command's first token.
105 Tokenize command string with shlex.split(comments=True). If replay is set,
106 a non-meta command from the commands_db merely triggers obey() on the next
107 command from the records file. If not, non-meta commands set
108 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
109 do_record is set, are recorded to io_db["record_chunk"], and save_world()
110 is called (and io_db["record_chunk"] written) if 15 seconds have passed
111 since the last time it was called. The prefix string is inserted into the
112 server's input message between its beginning 'input ' and ':'. All activity
113 is preceded by a server_test() call. Commands that start with a lowercase
114 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
118 print("input " + prefix + ": " + command)
120 tokens = shlex.split(command, comments=True)
121 except ValueError as err:
122 print("Can't tokenize command string: " + str(err) + ".")
124 if len(tokens) > 0 and tokens[0] in commands_db \
125 and len(tokens) == commands_db[tokens[0]][0] + 1:
126 if commands_db[tokens[0]][1]:
127 commands_db[tokens[0]][2](*tokens[1:])
128 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
129 print("Ignoring lowercase-starting commands when world inactive.")
131 print("Due to replay mode, reading command as 'go on in record'.")
132 line = io_db["file_record"].readline()
134 obey(line.rstrip(), io_db["file_record"].prefix
135 + str(io_db["file_record"].line_n))
136 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
138 print("Reached end of record file.")
140 commands_db[tokens[0]][2](*tokens[1:])
142 io_db["record_chunk"] += command + "\n"
143 if time.time() > io_db["save_wait"] + 15:
144 atomic_write(io_db["path_record"], io_db["record_chunk"],
146 if world_db["WORLD_ACTIVE"]:
148 io_db["record_chunk"] = ""
149 io_db["save_wait"] = time.time()
150 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
151 elif 0 != len(tokens):
152 print("Invalid command/argument, or bad number of tokens.")
155 def atomic_write(path, text, do_append=False, delete=True):
156 """Atomic write of text to file at path, appended if do_append is set."""
157 path_tmp = path + io_db["tmp_suffix"]
161 if os.access(path, os.F_OK):
162 shutil.copyfile(path, path_tmp)
163 file = open(path_tmp, mode)
164 strong_write(file, text)
166 if delete and os.access(path, os.F_OK):
168 os.rename(path_tmp, path)
172 """Save all commands needed to reconstruct current world state."""
175 string = string.replace("\u005C", '\u005C\u005C')
176 return '"' + string.replace('"', '\u005C"') + '"'
181 if key == "MAP" or world_db["Things"][id][key]:
182 map = world_db["MAP"] if key == "MAP" \
183 else world_db["Things"][id][key]
184 length = world_db["MAP_LENGTH"]
185 for i in range(length):
186 line = map[i * length:(i * length) + length].decode()
187 string = string + key + " " + str(i) + " " + quote(line) \
194 for memthing in world_db["Things"][id]["T_MEMTHING"]:
195 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
196 str(memthing[1]) + " " + str(memthing[2]) + "\n"
199 def helper(category, id_string, special_keys={}):
201 for id in world_db[category]:
202 string = string + id_string + " " + str(id) + "\n"
203 for key in world_db[category][id]:
204 if not key in special_keys:
205 x = world_db[category][id][key]
206 argument = quote(x) if str == type(x) else str(x)
207 string = string + key + " " + argument + "\n"
208 elif special_keys[key]:
209 string = string + special_keys[key](id)
214 if (dict != type(world_db[key])
215 and key != "altar" # #
216 and key != "MAP" and key != "WORLD_ACTIVE"):
217 string = string + key + " " + str(world_db[key]) + "\n"
218 string = string + mapsetter("MAP")()
219 string = string + helper("ThingActions", "TA_ID")
220 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
221 for id in world_db["ThingTypes"]:
222 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
223 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
224 string = string + helper("Things", "T_ID",
225 {"T_CARRIES": False, "carried": False,
226 "T_MEMMAP": mapsetter("T_MEMMAP"),
227 "T_MEMTHING": memthing, "fovmap": False,
228 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
229 for id in world_db["Things"]:
230 if [] != world_db["Things"][id]["T_CARRIES"]:
231 string = string + "T_ID " + str(id) + "\n"
232 for carried_id in world_db["Things"][id]["T_CARRIES"]:
233 string = string + "T_CARRIES " + str(carried_id) + "\n"
234 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
235 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
236 atomic_write(io_db["path_save"], string)
239 def obey_lines_in_file(path, name, do_record=False):
240 """Call obey() on each line of path's file, use name in input prefix."""
241 file = open(path, "r")
243 for line in file.readlines():
244 obey(line.rstrip(), name + "file line " + str(line_n),
250 def parse_command_line_arguments():
251 """Return settings values read from command line arguments."""
252 parser = argparse.ArgumentParser()
253 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
255 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
257 parser.add_argument('-v', dest='verbose', action='store_true')
258 opts, unknown = parser.parse_known_args()
263 """Ensure valid server out file belonging to current process.
265 This is done by comparing io_db["teststring"] to what's found at the start
266 of the current file at io_db["path_out"]. On failure, set
267 io_db["kicked_by_rival"] and raise SystemExit.
269 if not os.access(io_db["path_out"], os.F_OK):
270 raise SystemExit("Server output file has disappeared.")
271 file = open(io_db["path_out"], "r")
272 test = file.readline().rstrip("\n")
274 if test != io_db["teststring"]:
275 io_db["kicked_by_rival"] = True
276 msg = "Server test string in server output file does not match. This" \
277 " indicates that the current server process has been " \
278 "superseded by another one."
279 raise SystemExit(msg)
283 """Return next newline-delimited command from server in file.
285 Keep building return string until a newline is encountered. Pause between
286 unsuccessful reads, and after too much waiting, run server_test().
288 wait_on_fail = 0.03333
293 add = io_db["file_in"].readline()
295 command = command + add
296 if len(command) > 0 and "\n" == command[-1]:
297 command = command[:-1]
300 time.sleep(wait_on_fail)
301 if now + max_wait < time.time():
307 def try_worldstate_update():
308 """Write worldstate file if io_db["worldstate_updateable"] is set."""
309 if io_db["worldstate_updateable"]:
311 def draw_visible_Things(map, run):
312 for id in world_db["Things"]:
313 type = world_db["Things"][id]["T_TYPE"]
314 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
315 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
316 if (0 == run and not consumable and not alive) \
317 or (1 == run and consumable and not alive) \
318 or (2 == run and alive):
319 y = world_db["Things"][id]["T_POSY"]
320 x = world_db["Things"][id]["T_POSX"]
321 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
322 if 'v' == chr(fovflag):
323 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
324 map[(y * length) + x] = ord(c)
326 def write_map(string, map):
327 for i in range(length):
328 line = map[i * length:(i * length) + length].decode()
329 string = string + line + "\n"
333 if [] == world_db["Things"][0]["T_CARRIES"]:
334 inventory = "(none)\n"
336 for id in world_db["Things"][0]["T_CARRIES"]:
337 type_id = world_db["Things"][id]["T_TYPE"]
338 name = world_db["ThingTypes"][type_id]["TT_NAME"]
339 inventory = inventory + name + "\n"
340 # 7DRL additions: GOD_MOOD, GOD_FAVOR
341 string = str(world_db["TURN"]) + "\n" + \
342 str(world_db["GOD_MOOD"]) + "\n" + \
343 str(world_db["GOD_FAVOR"]) + "\n" + \
344 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
345 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
346 inventory + "%\n" + \
347 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
348 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
349 str(world_db["MAP_LENGTH"]) + "\n"
350 length = world_db["MAP_LENGTH"]
351 fov = bytearray(b' ' * (length ** 2))
352 for pos in range(length ** 2):
353 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
354 fov[pos] = world_db["MAP"][pos]
356 draw_visible_Things(fov, i)
357 string = write_map(string, fov)
358 mem = world_db["Things"][0]["T_MEMMAP"][:]
360 for mt in world_db["Things"][0]["T_MEMTHING"]:
361 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
362 if (i == 0 and not consumable) or (i == 1 and consumable):
363 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
364 mem[(mt[1] * length) + mt[2]] = ord(c)
365 string = write_map(string, mem)
366 atomic_write(io_db["path_worldstate"], string, delete=False)
367 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
368 io_db["worldstate_updateable"] = False
372 """Replay game from record file.
374 Use opts.replay as breakpoint turn to which to replay automatically before
375 switching to manual input by non-meta commands in server input file
376 triggering further reads of record file. Ensure opts.replay is at least 1.
377 Run try_worldstate_update() before each interactive obey()/read_command().
381 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
382 " (if so late a turn is to be found).")
383 if not os.access(io_db["path_record"], os.F_OK):
384 raise SystemExit("No record file found to replay.")
385 io_db["file_record"] = open(io_db["path_record"], "r")
386 io_db["file_record"].prefix = "record file line "
387 io_db["file_record"].line_n = 1
388 while world_db["TURN"] < opts.replay:
389 line = io_db["file_record"].readline()
392 obey(line.rstrip(), io_db["file_record"].prefix
393 + str(io_db["file_record"].line_n))
394 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
396 try_worldstate_update()
397 obey(read_command(), "in file", replay=True)
401 """Play game by server input file commands. Before, load save file found.
403 If no save file is found, a new world is generated from the commands in the
404 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
405 command and all that follow via the server input file. Run
406 try_worldstate_update() before each interactive obey()/read_command().
408 if os.access(io_db["path_save"], os.F_OK):
409 obey_lines_in_file(io_db["path_save"], "save")
411 if not os.access(io_db["path_worldconf"], os.F_OK):
412 msg = "No world config file from which to start a new world."
413 raise SystemExit(msg)
414 obey_lines_in_file(io_db["path_worldconf"], "world config ",
416 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
418 try_worldstate_update()
419 obey(read_command(), "in file", do_record=True)
423 """(Re-)make island map.
425 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
426 start with one land cell in the middle, then go into cycle of repeatedly
427 selecting a random sea cell and transforming it into land if it is neighbor
428 to land. The cycle ends when a land cell is due to be created at the map's
429 border. Then put some trees on the map (TODO: more precise algorithm desc).
431 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
433 def is_neighbor(coordinates, type):
436 length = world_db["MAP_LENGTH"]
438 diag_west = x + (ind > 0)
439 diag_east = x + (ind < (length - 1))
440 pos = (y * length) + x
441 if (y > 0 and diag_east
442 and type == chr(world_db["MAP"][pos - length + ind])) \
444 and type == chr(world_db["MAP"][pos + 1])) \
445 or (y < (length - 1) and diag_east
446 and type == chr(world_db["MAP"][pos + length + ind])) \
447 or (y > 0 and diag_west
448 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
450 and type == chr(world_db["MAP"][pos - 1])) \
451 or (y < (length - 1) and diag_west
452 and type == chr(world_db["MAP"][pos + length - (not ind)])):
456 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
457 length = world_db["MAP_LENGTH"]
458 add_half_width = (not (length % 2)) * int(length / 2)
459 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
461 y = rand.next() % length
462 x = rand.next() % length
463 pos = (y * length) + x
464 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
465 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
467 world_db["MAP"][pos] = ord(".")
468 n_trees = int((length ** 2) / 16)
470 while (i_trees <= n_trees):
471 single_allowed = rand.next() % 32
472 y = rand.next() % length
473 x = rand.next() % length
474 pos = (y * length) + x
475 if "." == chr(world_db["MAP"][pos]) \
476 and ((not single_allowed) or is_neighbor((y, x), "X")):
477 world_db["MAP"][pos] = ord("X")
479 # This all-too-precise replica of the original C code misses iter_limit().
480 n_colons = int((length ** 2) / 16) # #
482 while (i_colons <= n_colons): # #
483 single_allowed = rand.next() % 256 # #
484 y = rand.next() % length # #
485 x = rand.next() % length # #
486 pos = (y * length) + x # #
487 if ("." == chr(world_db["MAP"][pos]) # #
488 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
489 world_db["MAP"][pos] = ord(":") # #
491 altar_placed = False # #
492 while not altar_placed: # #
493 y = rand.next() % length # #
494 x = rand.next() % length # #
495 pos = (y * length) + x # #
496 if (("." == chr(world_db["MAP"][pos] # #
497 or ":" == chr(world_db["MAP"][pos]))
498 and not is_neighbor((y, x), 'X'))): # #
499 world_db["MAP"][pos] = ord("_") # #
500 world_db["altar"] = (y, x) # #
501 altar_placed = True # #
504 def update_map_memory(t, age_map=True):
505 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
507 def age_some_memdepthmap_on_nonfov_cells():
508 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
512 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
513 # if not ord_v == t["fovmap"][pos]
514 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
515 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
516 # if not rand.next() % (2 **
517 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
518 # t["T_MEMDEPTHMAP"][pos] += 1
519 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
520 fovmap = c_pointer_to_bytearray(t["fovmap"])
521 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
523 if not t["T_MEMMAP"]:
524 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
525 if not t["T_MEMDEPTHMAP"]:
526 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
530 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
531 if ord_v == t["fovmap"][pos]]:
532 t["T_MEMDEPTHMAP"][pos] = ord_0
533 if ord_space == t["T_MEMMAP"][pos]:
534 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
536 age_some_memdepthmap_on_nonfov_cells()
537 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
538 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
540 for id in [id for id in world_db["Things"]
541 if not world_db["Things"][id]["carried"]]:
542 type = world_db["Things"][id]["T_TYPE"]
543 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
544 y = world_db["Things"][id]["T_POSY"]
545 x = world_db["Things"][id]["T_POSX"]
546 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
547 t["T_MEMTHING"].append((type, y, x))
550 def set_world_inactive():
551 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
553 if os.access(io_db["path_worldstate"], os.F_OK):
554 os.remove(io_db["path_worldstate"])
555 world_db["WORLD_ACTIVE"] = 0
558 def integer_test(val_string, min, max=None):
559 """Return val_string if possible integer >= min and <= max, else None."""
561 val = int(val_string)
562 if val < min or (max is not None and val > max):
566 msg = "Ignoring: Please use integer >= " + str(min)
568 msg += " and <= " + str(max)
574 def setter(category, key, min, max=None):
575 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
578 val = integer_test(val_string, min, max)
582 if category == "Thing":
583 id_store = command_tid
584 decorator = test_Thing_id
585 elif category == "ThingType":
586 id_store = command_ttid
587 decorator = test_ThingType_id
588 elif category == "ThingAction":
589 id_store = command_taid
590 decorator = test_ThingAction_id
594 val = integer_test(val_string, min, max)
596 world_db[category + "s"][id_store.id][key] = val
600 def build_fov_map(t):
601 """Build Thing's FOV map."""
602 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
603 fovmap = c_pointer_to_bytearray(t["fovmap"])
604 map = c_pointer_to_bytearray(world_db["MAP"])
605 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
606 raise RuntimeError("Malloc error in build_fov_Map().")
610 """Send quick usage info to log."""
611 strong_write(io_db["file_out"], "LOG "
612 + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n")
613 strong_write(io_db["file_out"], "LOG "
614 + "Use 'p' to pick up objects, and 'D' to drop them.\n")
615 strong_write(io_db["file_out"], "LOG "
616 + "Some objects can be used (such as: eaten) by 'u' if "
617 + "they are in your inventory. "
618 + "Use 'UP'/'DOWN' to navigate the inventory.\n")
619 strong_write(io_db["file_out"], "LOG "
620 + "Use 'l' to toggle 'look' mode (move an exploration cursor "
621 + "instead of the player over the map).\n")
622 strong_write(io_db["file_out"], "LOG See README file for more details.\n")
623 strong_write(io_db["file_out"], "LOG \n")
626 def decrement_lifepoints(t):
627 """Decrement t's lifepoints by 1, and if to zero, corpse it.
629 If t is the player avatar, only blank its fovmap, so that the client may
630 still display memory data. On non-player things, erase fovmap and memory.
631 Dying actors drop all their things.
633 # 7DRL: Also decrements God's mood; deaths heavily so.
634 # 7DRL: Return 1 if death, else 0.
635 t["T_LIFEPOINTS"] -= 1
636 world_db["GOD_MOOD"] -= 1 # #
637 if 0 == t["T_LIFEPOINTS"]:
638 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
639 world_db["GOD_MOOD"] -= sadness # #
640 for id in t["T_CARRIES"]:
641 t["T_CARRIES"].remove(id)
642 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
643 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
644 world_db["Things"][id]["carried"] = False
645 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
646 if world_db["Things"][0] == t:
647 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
648 strong_write(io_db["file_out"], "LOG You die.\n")
649 strong_write(io_db["file_out"],
650 "LOG See README on how to start over.\n")
653 t["T_MEMMAP"] = False
654 t["T_MEMDEPTHMAP"] = False
660 def add_gods_favor(i): # #
661 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
662 def favor_multiplier(i):
664 threshold = math.e * x
665 mood = world_db["GOD_MOOD"]
668 i = i * math.log(mood / x)
669 elif -mood > threshold:
670 i = i / math.log(-mood / x)
672 if -mood > threshold:
673 i = i * math.log(-mood / x)
675 i = i / math.log(mood / x)
677 world_db["GOD_FAVOR"] += favor_multiplier(i)
680 def mv_yx_in_dir_legal(dir, y, x):
681 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
682 dir_c = dir.encode("ascii")[0]
683 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
685 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
686 return (test, libpr.result_y(), libpr.result_x())
689 def enter_altar(): # #
690 """What happens when the player enters the altar."""
691 if world_db["FAVOR_STAGE"] > 9000:
692 strong_write(io_db["file_out"],
693 "LOG You step on a soul-less slab of stone.\n")
695 strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
696 if world_db["FAVOR_STAGE"] == 0:
697 world_db["FAVOR_STAGE"] = 1
698 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
699 + "\"I don't trust you. You intrude on the island's "
700 + "affairs. I think you're a nuisance at best, and a "
701 + "danger to my children at worst. I will give you a "
702 + "chance to lighten my mood, however: For a while now, "
703 + "I've been trying to spread the plant "
704 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
706 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
707 + "\"). I have not been very successful so far. Maybe "
708 + "you can make yourself useful there. I will count "
710 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
711 + " that grows to your favor.\n")
712 elif world_db["GOD_FAVOR"] > 9000:
713 world_db["FAVOR_STAGE"] = 9001
714 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
715 + "\"You have proven yourself worthy of my respect. "
716 + "You were a good citizen to the island, and sometimes "
717 + "a better steward to its inhabitants than me. The "
718 + "island shall miss you when you leave. But you have "
719 + "earned the right to do so. Take this "
720 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
721 + " and USE it when you please. It will take you to "
722 + "where you came from. (But do feel free to stay here "
723 + "as long as you like.)\"\n")
724 id = id_setter(-1, "Things")
725 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
730 """Make t do nothing (but loudly, if player avatar)."""
731 if t == world_db["Things"][0]:
732 strong_write(io_db["file_out"], "LOG You wait.\n")
736 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
737 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
738 # 7DRL: Player entering the altar triggers enter_altar().
740 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
741 t["T_POSY"], t["T_POSX"])
742 if 1 == move_result[0]:
743 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
744 passable = ("." == chr(world_db["MAP"][pos]) or
745 ":" == chr(world_db["MAP"][pos]) or # #
746 "_" == chr(world_db["MAP"][pos])) # #
747 hitted = [id for id in world_db["Things"]
748 if world_db["Things"][id] != t
749 if world_db["Things"][id]["T_LIFEPOINTS"]
750 if world_db["Things"][id]["T_POSY"] == move_result[1]
751 if world_db["Things"][id]["T_POSX"] == move_result[2]]
754 if t == world_db["Things"][0]:
755 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
756 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
757 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
759 add_gods_favor(-1) # #
761 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
762 strong_write(io_db["file_out"], "LOG " + hitter_name +
764 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
765 if test and t == world_db["Things"][0]: # #
766 add_gods_favor(-test) # #
768 dir = [dir for dir in directions_db
769 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
771 t["T_POSY"] = move_result[1]
772 t["T_POSX"] = move_result[2]
773 for id in t["T_CARRIES"]:
774 world_db["Things"][id]["T_POSY"] = move_result[1]
775 world_db["Things"][id]["T_POSX"] = move_result[2]
777 if t == world_db["Things"][0]:
778 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
779 if (move_result[1] == world_db["altar"][0] and # #
780 move_result[2] == world_db["altar"][1]): # #
782 elif t == world_db["Things"][0]:
783 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
786 def actor_pick_up(t):
787 """Make t pick up (topmost?) Thing from ground into inventory."""
788 # Topmostness is actually not defined so far. Picks most nutritious Thing.
789 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
790 used_slots = len(t["T_CARRIES"]) # #
791 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
792 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
793 if not world_db["Things"][id]["carried"]
794 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
795 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
800 type = world_db["Things"][id]["T_TYPE"]
801 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
802 nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
804 world_db["Things"][highest_id]["carried"] = True
805 if (t != world_db["Things"][0] and # #
806 world_db["Things"][highest_id]["T_PLAYERDROP"]): # #
807 x = world_db["Things"][highest_id]["T_TYPE"]
808 score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32 # #
809 add_gods_favor(score) # #
810 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0 # #
811 t["T_CARRIES"].append(highest_id)
812 if t == world_db["Things"][0]:
813 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
814 elif t == world_db["Things"][0]:
815 err = "You try to pick up an object, but there is none."
816 strong_write(io_db["file_out"], "LOG " + err + "\n")
817 elif t == world_db["Things"][0]: # #
818 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
819 "No storage room to carry more.\n") # #
823 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
824 # TODO: Handle case where T_ARGUMENT matches nothing.
825 if len(t["T_CARRIES"]):
826 id = t["T_CARRIES"][t["T_ARGUMENT"]]
827 t["T_CARRIES"].remove(id)
828 world_db["Things"][id]["carried"] = False
829 if t == world_db["Things"][0]:
830 strong_write(io_db["file_out"], "LOG You drop an object.\n")
831 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
832 elif t == world_db["Things"][0]:
833 err = "You try to drop an object, but you own none."
834 strong_write(io_db["file_out"], "LOG " + err + "\n")
838 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
839 # TODO: Handle case where T_ARGUMENT matches nothing.
840 # 7DLR: Handle SLIPPERS-type Thing use.
841 if len(t["T_CARRIES"]):
842 id = t["T_CARRIES"][t["T_ARGUMENT"]]
843 type = world_db["Things"][id]["T_TYPE"]
844 if type == world_db["SLIPPERS"]: # #
845 if t == world_db["Things"][0]: # #
846 strong_write(io_db["file_out"], "LOG You use the " # #
847 + world_db["ThingTypes"][type]["TT_NAME"] # #
848 + ". It glows in wondrous colors, and emits " # #
849 + "a sound as if from a dying cat. The " # #
850 + "Island God laughs.\n") # #
851 t["T_LIFEPOINTS"] = 1 # #
852 decrement_lifepoints(t) # #
853 elif world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
854 t["T_CARRIES"].remove(id)
855 del world_db["Things"][id]
856 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
857 if t == world_db["Things"][0]:
858 strong_write(io_db["file_out"],
859 "LOG You consume this object.\n")
860 elif t == world_db["Things"][0]:
861 strong_write(io_db["file_out"],
862 "LOG You try to use this object, but fail.\n")
863 elif t == world_db["Things"][0]:
864 strong_write(io_db["file_out"],
865 "LOG You try to use an object, but you own none.\n")
868 def thingproliferation(t, prol_map):
869 """To chance of 1/TT_PROLIFERATE,create t offspring in open neighbor cell.
871 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
872 marked "." in prol_map. If there are several map cell candidates, one is
875 # 7DRL: success increments God's mood
876 # 7DRL: Things proliferate only on ":" ground.
877 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
878 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
880 for dir in [directions_db[key] for key in directions_db]:
881 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
882 if mv_result[0] and ord(":") == prol_map[mv_result[1] # #
883 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
884 * world_db["MAP_LENGTH"]
886 candidates.append((mv_result[1], mv_result[2]))
888 i = rand.next() % len(candidates)
889 id = id_setter(-1, "Things")
890 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
891 world_db["Things"][id] = newT
892 world_db["GOD_MOOD"] += 1 # #
893 if (world_db["FAVOR_STAGE"] > 0 # #
894 and t["T_TYPE"] == world_db["PLANT_0"]):
895 world_db["GOD_FAVOR"] += 5
899 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
901 On success, decrease satiation score by 32.
903 # 7DRL: Successful heals increment God's mood.
904 if t["T_SATIATION"] > 0 \
905 and t["T_LIFEPOINTS"] < \
906 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
907 and 0 == (rand.next() % 31) \
908 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
909 if world_db["ThingActions"][id]["TA_NAME"] ==
911 t["T_LIFEPOINTS"] += 1
912 world_db["GOD_MOOD"] += 1 # #
913 t["T_SATIATION"] -= 32
914 if t == world_db["Things"][0]:
915 strong_write(io_db["file_out"], "LOG You heal.\n")
919 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
920 if t["T_SATIATION"] > -32768:
921 t["T_SATIATION"] -= 1
922 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
923 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
924 raise RuntimeError("A thing that should not hunger is hungering.")
925 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
926 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
927 if t == world_db["Things"][0]:
928 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
929 decrement_lifepoints(t)
932 def get_dir_to_target(t, filter):
933 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
935 The path-wise nearest target is chosen, via the shortest available path.
936 Target must not be t. On succcess, return positive value, else False.
938 "a": Thing in FOV is below a certain distance, animate, but of ThingType
939 that is not t's, and starts out weaker than t is; build path as
940 avoiding things of t's ThingType
941 "f": neighbor cell (not inhabited by any animate Thing) further away from
942 animate Thing not further than x steps away and in FOV and of a
943 ThingType that is not t's, and starts out stronger or as strong as t
944 is currently; or (cornered), if no such flight cell, but Thing of
945 above criteria is too near,1 a cell closer to it, or, if less near,
947 "c": Thing in memorized map is consumable
948 "s": memory map cell with greatest-reachable degree of unexploredness
951 def zero_score_map_where_char_on_memdepthmap(c):
952 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
953 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
954 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
955 # set_map_score(i, 0)
956 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
957 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
958 raise RuntimeError("No score map allocated for "
959 "zero_score_map_where_char_on_memdepthmap().")
961 def set_map_score(pos, score):
962 test = libpr.set_map_score(pos, score)
964 raise RuntimeError("No score map allocated for set_map_score().")
966 def get_map_score(pos):
967 result = libpr.get_map_score(pos)
969 raise RuntimeError("No score map allocated for get_map_score().")
973 if t["fovmap"] and ("a" == filter or "f" == filter):
974 for id in world_db["Things"]:
975 Thing = world_db["Things"][id]
976 if Thing != t and Thing["T_LIFEPOINTS"] and \
977 t["T_TYPE"] != Thing["T_TYPE"] and \
978 'v' == chr(t["fovmap"][(Thing["T_POSY"]
979 * world_db["MAP_LENGTH"])
981 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
982 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
984 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
987 elif t["T_MEMMAP"] and "c" == filter:
988 for mt in t["T_MEMTHING"]:
989 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
991 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
995 def set_cells_passable_on_memmap_to_65534_on_scoremap():
996 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
998 # memmap = t["T_MEMMAP"]
999 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1000 # if ord_dot == memmap[i]]:
1001 # set_map_score(i, 65534) # i.e. 65535-1
1002 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1003 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1004 raise RuntimeError("No score map allocated for "
1005 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1007 def init_score_map():
1008 test = libpr.init_score_map()
1010 raise RuntimeError("Malloc error in init_score_map().")
1012 ord_blank = ord(" ")
1013 set_cells_passable_on_memmap_to_65534_on_scoremap()
1015 for id in world_db["Things"]:
1016 Thing = world_db["Things"][id]
1017 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1019 if t != Thing and Thing["T_LIFEPOINTS"] and \
1020 t["T_TYPE"] != Thing["T_TYPE"] and \
1021 ord_v == t["fovmap"][pos] and \
1022 t["T_LIFEPOINTS"] > \
1023 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1024 set_map_score(pos, 0)
1025 elif t["T_TYPE"] == Thing["T_TYPE"]:
1026 set_map_score(pos, 65535)
1028 for id in [id for id in world_db["Things"]
1029 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1030 Thing = world_db["Things"][id]
1031 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1033 if t["T_TYPE"] != Thing["T_TYPE"] and \
1034 ord_v == t["fovmap"][pos] and \
1035 t["T_LIFEPOINTS"] <= \
1036 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1037 set_map_score(pos, 0)
1039 for mt in [mt for mt in t["T_MEMTHING"]
1040 if ord_blank != t["T_MEMMAP"][mt[1]
1041 * world_db["MAP_LENGTH"]
1043 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
1044 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1046 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1048 def rand_target_dir(neighbors, cmp, dirs):
1051 for i in range(len(dirs)):
1052 if cmp == neighbors[i]:
1053 candidates.append(dirs[i])
1055 return candidates[rand.next() % n_candidates] if n_candidates else 0
1057 def get_neighbor_scores(dirs, eye_pos):
1059 if libpr.ready_neighbor_scores(eye_pos):
1060 raise RuntimeError("No score map allocated for " +
1061 "ready_neighbor_scores.()")
1062 for i in range(len(dirs)):
1063 scores.append(libpr.get_neighbor_score(i))
1066 def get_dir_from_neighbors():
1067 dir_to_target = False
1069 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1070 neighbors = get_neighbor_scores(dirs, eye_pos)
1072 inhabited = [world_db["Things"][id]["T_POSY"]
1073 * world_db["MAP_LENGTH"]
1074 + world_db["Things"][id]["T_POSX"]
1075 for id in world_db["Things"]
1076 if world_db["Things"][id]["T_LIFEPOINTS"]]
1077 for i in range(len(dirs)):
1078 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1079 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1081 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1082 neighbors[i] = 65535
1084 minmax_start = 0 if "f" == filter else 65535 - 1
1085 minmax_neighbor = minmax_start
1086 for i in range(len(dirs)):
1087 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1088 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1089 or ("f" != filter and minmax_neighbor > neighbors[i]):
1090 minmax_neighbor = neighbors[i]
1091 if minmax_neighbor != minmax_start:
1092 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1094 if not dir_to_target:
1095 if 1 == get_map_score(eye_pos):
1096 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1097 elif 3 >= get_map_score(eye_pos):
1098 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1100 world_db["ThingActions"][id]["TA_NAME"]
1103 elif dir_to_target and 3 < get_map_score(eye_pos):
1105 elif "a" == filter and 10 <= get_map_score(eye_pos):
1107 return dir_to_target
1109 dir_to_target = False
1111 run_i = 9 + 1 if "s" == filter else 1
1112 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1115 mem_depth_c = b'9' if b' ' == mem_depth_c \
1116 else bytes([mem_depth_c[0] - 1])
1117 if libpr.dijkstra_map():
1118 raise RuntimeError("No score map allocated for dijkstra_map().")
1119 dir_to_target = get_dir_from_neighbors()
1120 libpr.free_score_map()
1121 if dir_to_target and str == type(dir_to_target):
1122 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1123 if world_db["ThingActions"][id]["TA_NAME"]
1125 t["T_ARGUMENT"] = ord(dir_to_target)
1126 return dir_to_target
1129 def standing_on_consumable(t):
1130 """Return True/False whether t is standing on a consumable."""
1131 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1132 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1133 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1134 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1140 def get_inventory_slot_to_consume(t):
1141 """Return slot Id of strongest consumable in t's inventory, else -1."""
1142 cmp_consumability = 0
1145 for id in t["T_CARRIES"]:
1146 type = world_db["Things"][id]["T_TYPE"]
1147 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
1148 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1155 """Determine next command/argment for actor t via AI algorithms.
1157 AI will look for, and move towards, enemies (animate Things not of their
1158 own ThingType); if they see none, they will consume consumables in their
1159 inventory; if there are none, they will pick up what they stand on if they
1160 stand on consumables; if they stand on none, they will move towards the
1161 next consumable they see or remember on the map; if they see or remember
1162 none, they will explore parts of the map unseen since ever or for at least
1163 one turn; if there is nothing to explore, they will simply wait.
1165 # 7DRL add: Don't pick up or search things when inventory is full.
1166 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1167 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1168 if not get_dir_to_target(t, "f"):
1169 sel = get_inventory_slot_to_consume(t)
1171 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1172 if world_db["ThingActions"][id]["TA_NAME"]
1174 t["T_ARGUMENT"] = sel
1175 elif standing_on_consumable(t) \
1176 and (len(t["T_CARRIES"]) < # #
1177 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1178 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1179 if world_db["ThingActions"][id]["TA_NAME"]
1182 (len(t["T_CARRIES"]) < # #
1183 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1184 and get_dir_to_target(t, "c"))) and \
1185 (not get_dir_to_target(t, "a")):
1186 get_dir_to_target(t, "s")
1190 """Run game world and its inhabitants until new player input expected."""
1192 whilebreaker = False
1193 while world_db["Things"][0]["T_LIFEPOINTS"]:
1194 proliferable_map = world_db["MAP"][:]
1195 for id in [id for id in world_db["Things"]
1196 if not world_db["Things"][id]["carried"]]:
1197 y = world_db["Things"][id]["T_POSY"]
1198 x = world_db["Things"][id]["T_POSX"]
1199 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1200 for id in [id for id in world_db["Things"]]: # Only what's from start!
1201 if not id in world_db["Things"] or \
1202 world_db["Things"][id]["carried"]: # May have been consumed or
1203 continue # picked up during turn …
1204 Thing = world_db["Things"][id]
1205 if Thing["T_LIFEPOINTS"]:
1206 if not Thing["T_COMMAND"]:
1207 update_map_memory(Thing)
1214 if Thing["T_LIFEPOINTS"]:
1215 Thing["T_PROGRESS"] += 1
1216 taid = [a for a in world_db["ThingActions"]
1217 if a == Thing["T_COMMAND"]][0]
1218 ThingAction = world_db["ThingActions"][taid]
1219 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1220 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1221 Thing["T_COMMAND"] = 0
1222 Thing["T_PROGRESS"] = 0
1223 thingproliferation(Thing, proliferable_map)
1226 world_db["TURN"] += 1
1229 def new_Thing(type, pos=(0, 0)):
1230 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1232 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1237 "T_PLAYERDROP": 0, # #
1245 "T_MEMDEPTHMAP": False,
1248 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1249 build_fov_map(thing)
1253 def id_setter(id, category, id_store=False, start_at_1=False):
1254 """Set ID of object of category to manipulate ID unused? Create new one.
1256 The ID is stored as id_store.id (if id_store is set). If the integer of the
1257 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1258 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1259 always returned when no new object is created, otherwise the new object's
1262 min = 0 if start_at_1 else -1
1264 id = integer_test(id, min)
1266 if id in world_db[category]:
1271 if (start_at_1 and 0 == id) \
1272 or ((not start_at_1) and (id < 0)):
1273 id = 0 if start_at_1 else -1
1276 if id not in world_db[category]:
1284 """Send PONG line to server output file."""
1285 strong_write(io_db["file_out"], "PONG\n")
1289 """Abort server process."""
1290 if None == opts.replay:
1291 if world_db["WORLD_ACTIVE"]:
1293 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1294 raise SystemExit("received QUIT command")
1297 def command_thingshere(str_y, str_x):
1298 """Write to out file list of Things known to player at coordinate y, x."""
1299 if world_db["WORLD_ACTIVE"]:
1300 y = integer_test(str_y, 0, 255)
1301 x = integer_test(str_x, 0, 255)
1302 length = world_db["MAP_LENGTH"]
1303 if None != y and None != x and y < length and x < length:
1304 pos = (y * world_db["MAP_LENGTH"]) + x
1305 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1306 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1307 for id in world_db["Things"]:
1308 if y == world_db["Things"][id]["T_POSY"] \
1309 and x == world_db["Things"][id]["T_POSX"] \
1310 and not world_db["Things"][id]["carried"]:
1311 type = world_db["Things"][id]["T_TYPE"]
1312 name = world_db["ThingTypes"][type]["TT_NAME"]
1313 strong_write(io_db["file_out"], name + "\n")
1315 for mt in world_db["Things"][0]["T_MEMTHING"]:
1316 if y == mt[1] and x == mt[2]:
1317 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1318 strong_write(io_db["file_out"], name + "\n")
1319 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1321 print("Ignoring: Invalid map coordinates.")
1323 print("Ignoring: Command only works on existing worlds.")
1326 def play_commander(action, args=False):
1327 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1329 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1333 id = [x for x in world_db["ThingActions"]
1334 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1335 world_db["Things"][0]["T_COMMAND"] = id
1338 def set_command_and_argument_int(str_arg):
1339 val = integer_test(str_arg, 0, 255)
1341 world_db["Things"][0]["T_ARGUMENT"] = val
1344 def set_command_and_argument_movestring(str_arg):
1345 if str_arg in directions_db:
1346 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1349 print("Ignoring: Argument must be valid direction string.")
1351 if action == "move":
1352 return set_command_and_argument_movestring
1354 return set_command_and_argument_int
1359 def command_seedrandomness(seed_string):
1360 """Set rand seed to int(seed_string)."""
1361 val = integer_test(seed_string, 0, 4294967295)
1366 def command_makeworld(seed_string):
1367 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1369 Seed rand with seed. Do more only with a "wait" ThingAction and
1370 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1371 world_db["Things"] emptied, call make_map() and set
1372 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1373 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1374 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1375 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1379 # def free_pos(plant=False):
1380 def free_pos(plant=False): # #
1383 err = "Space to put thing on too hard to find. Map too small?"
1385 y = rand.next() % world_db["MAP_LENGTH"]
1386 x = rand.next() % world_db["MAP_LENGTH"]
1387 pos = y * world_db["MAP_LENGTH"] + x;
1389 and "." == chr(world_db["MAP"][pos])) \
1390 or ":" == chr(world_db["MAP"][pos]): # #
1394 raise SystemExit(err)
1395 # Replica of C code, wrongly ignores animatedness of new Thing.
1396 pos_clear = (0 == len([id for id in world_db["Things"]
1397 if world_db["Things"][id]["T_LIFEPOINTS"]
1398 if world_db["Things"][id]["T_POSY"] == y
1399 if world_db["Things"][id]["T_POSX"] == x]))
1404 val = integer_test(seed_string, 0, 4294967295)
1408 player_will_be_generated = False
1409 playertype = world_db["PLAYER_TYPE"]
1410 for ThingType in world_db["ThingTypes"]:
1411 if playertype == ThingType:
1412 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1413 player_will_be_generated = True
1415 if not player_will_be_generated:
1416 print("Ignoring: No player type with start number >0 defined.")
1419 for ThingAction in world_db["ThingActions"]:
1420 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1423 print("Ignoring: No thing action with name 'wait' defined.")
1425 if not world_db["SLIPPERS"] in world_db["ThingTypes"]: # #
1426 print("Ignoring: No valid SLIPPERS set.") # #
1428 if not world_db["PLANT_0"] in world_db["ThingTypes"]: # #
1429 print("Ignoring: No valid PLANT_0 set.") # #
1431 world_db["Things"] = {}
1433 world_db["WORLD_ACTIVE"] = 1
1434 world_db["TURN"] = 1
1435 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1436 id = id_setter(-1, "Things")
1437 world_db["Things"][id] = new_Thing(playertype, free_pos())
1438 if not world_db["Things"][0]["fovmap"]:
1439 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1440 world_db["Things"][0]["fovmap"] = empty_fovmap
1441 update_map_memory(world_db["Things"][0])
1442 for type in world_db["ThingTypes"]:
1443 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1444 if type != playertype:
1445 id = id_setter(-1, "Things")
1446 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1447 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1448 strong_write(io_db["file_out"], "NEW_WORLD\n")
1452 def command_maplength(maplength_string):
1453 """Redefine map length. Invalidate map, therefore lose all things on it."""
1454 val = integer_test(maplength_string, 1, 256)
1456 world_db["MAP_LENGTH"] = val
1457 world_db["MAP"] = False
1458 set_world_inactive()
1459 world_db["Things"] = {}
1460 libpr.set_maplength(val)
1463 def command_worldactive(worldactive_string):
1464 """Toggle world_db["WORLD_ACTIVE"] if possible.
1466 An active world can always be set inactive. An inactive world can only be
1467 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1468 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1469 Also call log_help().
1471 # 7DRL: altar must be on map, and (valid) SLIPPERS and PLANT_0must be set
1472 # for world activation.
1473 val = integer_test(worldactive_string, 0, 1)
1475 if 0 != world_db["WORLD_ACTIVE"]:
1477 set_world_inactive()
1479 print("World already active.")
1480 elif 0 == world_db["WORLD_ACTIVE"]:
1482 for ThingAction in world_db["ThingActions"]:
1483 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1486 player_exists = False
1487 for Thing in world_db["Things"]:
1489 player_exists = True
1491 valid_slippers = world_db["SLIPPERS"] in world_db["ThingTypes"] # #
1492 valid_plant0 = world_db["PLANT_0"] in world_db["ThingTypes"] # #
1493 altar_found = False # #
1494 if world_db["MAP"]: # #
1495 pos = world_db["MAP"].find(b'_') # #
1497 y = int(pos / world_db["MAP_LENGTH"]) # #
1498 x = pos % world_db["MAP_LENGTH"] # #
1499 world_db["altar"] = (y, x) # #
1500 altar_found = True # #
1501 if wait_exists and player_exists and world_db["MAP"] \
1502 and altar_found and valid_slippers and valid_plant0: # #
1503 for id in world_db["Things"]:
1504 if world_db["Things"][id]["T_LIFEPOINTS"]:
1505 build_fov_map(world_db["Things"][id])
1507 update_map_memory(world_db["Things"][id], False)
1508 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1509 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1510 world_db["Things"][0]["fovmap"] = empty_fovmap
1511 world_db["WORLD_ACTIVE"] = 1
1514 print("Ignoring: Not all conditions for world activation met.")
1517 def command_slippers(str_int): # #
1518 """Set SLIPPERS, but deactivate world if not in ThingTypes."""
1519 val = integer_test(str_int, 0)
1521 world_db["SLIPPERS"] = val
1522 if world_db["WORLD_ACTIVE"] and \
1523 world_db["SLIPPERS"] not in world_db["ThingTypes"]:
1524 world_db["WORLD_ACTIVE"] = 0
1525 print("SLIPPERS matches no known ThingTypes, deactivating world.")
1528 def command_plant0(str_int): # #
1529 """Set PLANT_0, but deactivate world if not in ThingTypes."""
1530 val = integer_test(str_int, 0)
1532 world_db["PLANT_0"] = val
1533 if world_db["WORLD_ACTIVE"] and \
1534 world_db["PLANT_0"] not in world_db["ThingTypes"]:
1535 world_db["WORLD_ACTIVE"] = 0
1536 print("PLANT_0 matches no known ThingTypes, deactivating world.")
1539 def test_for_id_maker(object, category):
1540 """Return decorator testing for object having "id" attribute."""
1543 if hasattr(object, "id"):
1546 print("Ignoring: No " + category +
1547 " defined to manipulate yet.")
1552 def command_tid(id_string):
1553 """Set ID of Thing to manipulate. ID unused? Create new one.
1555 Default new Thing's type to the first available ThingType, others: zero.
1557 id = id_setter(id_string, "Things", command_tid)
1559 if world_db["ThingTypes"] == {}:
1560 print("Ignoring: No ThingType to settle new Thing in.")
1562 type = list(world_db["ThingTypes"].keys())[0]
1563 world_db["Things"][id] = new_Thing(type)
1566 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1570 def command_tcommand(str_int):
1571 """Set T_COMMAND of selected Thing."""
1572 val = integer_test(str_int, 0)
1574 if 0 == val or val in world_db["ThingActions"]:
1575 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1577 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1581 def command_ttype(str_int):
1582 """Set T_TYPE of selected Thing."""
1583 val = integer_test(str_int, 0)
1585 if val in world_db["ThingTypes"]:
1586 world_db["Things"][command_tid.id]["T_TYPE"] = val
1588 print("Ignoring: ThingType ID belongs to no known ThingType.")
1592 def command_tcarries(str_int):
1593 """Append int(str_int) to T_CARRIES of selected Thing.
1595 The ID int(str_int) must not be of the selected Thing, and must belong to a
1596 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1598 val = integer_test(str_int, 0)
1600 if val == command_tid.id:
1601 print("Ignoring: Thing cannot carry itself.")
1602 elif val in world_db["Things"] \
1603 and not world_db["Things"][val]["carried"]:
1604 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1605 world_db["Things"][val]["carried"] = True
1607 print("Ignoring: Thing not available for carrying.")
1608 # Note that the whole carrying structure is different from the C version:
1609 # Carried-ness is marked by a "carried" flag, not by Things containing
1610 # Things internally.
1614 def command_tmemthing(str_t, str_y, str_x):
1615 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1617 The type must fit to an existing ThingType, and the position into the map.
1619 type = integer_test(str_t, 0)
1620 posy = integer_test(str_y, 0, 255)
1621 posx = integer_test(str_x, 0, 255)
1622 if None != type and None != posy and None != posx:
1623 if type not in world_db["ThingTypes"] \
1624 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1625 print("Ignoring: Illegal value for thing type or position.")
1627 memthing = (type, posy, posx)
1628 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1631 def setter_map(maptype):
1632 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1634 If no map of maptype exists yet, initialize it with ' ' bytes first.
1637 def valid_map_line(str_int, mapline):
1638 val = integer_test(str_int, 0, 255)
1640 if val >= world_db["MAP_LENGTH"]:
1641 print("Illegal value for map line number.")
1642 elif len(mapline) != world_db["MAP_LENGTH"]:
1643 print("Map line length is unequal map width.")
1648 def nonThingMap_helper(str_int, mapline):
1649 val = valid_map_line(str_int, mapline)
1651 length = world_db["MAP_LENGTH"]
1652 if not world_db["MAP"]:
1653 map = bytearray(b' ' * (length ** 2))
1655 map = world_db["MAP"]
1656 map[val * length:(val * length) + length] = mapline.encode()
1657 if not world_db["MAP"]:
1658 world_db["MAP"] = map
1661 def ThingMap_helper(str_int, mapline):
1662 val = valid_map_line(str_int, mapline)
1664 length = world_db["MAP_LENGTH"]
1665 if not world_db["Things"][command_tid.id][maptype]:
1666 map = bytearray(b' ' * (length ** 2))
1668 map = world_db["Things"][command_tid.id][maptype]
1669 map[val * length:(val * length) + length] = mapline.encode()
1670 if not world_db["Things"][command_tid.id][maptype]:
1671 world_db["Things"][command_tid.id][maptype] = map
1673 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1676 def setter_tpos(axis):
1677 """Generate setter for T_POSX or T_POSY of selected Thing.
1679 If world is active, rebuilds animate things' fovmap, player's memory map.
1682 def helper(str_int):
1683 val = integer_test(str_int, 0, 255)
1685 if val < world_db["MAP_LENGTH"]:
1686 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1687 if world_db["WORLD_ACTIVE"] \
1688 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1689 build_fov_map(world_db["Things"][command_tid.id])
1690 if 0 == command_tid.id:
1691 update_map_memory(world_db["Things"][command_tid.id])
1693 print("Ignoring: Position is outside of map.")
1697 def command_ttid(id_string):
1698 """Set ID of ThingType to manipulate. ID unused? Create new one.
1700 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1702 id = id_setter(id_string, "ThingTypes", command_ttid)
1704 world_db["ThingTypes"][id] = {
1705 "TT_NAME": "(none)",
1708 "TT_PROLIFERATE": 0,
1709 "TT_START_NUMBER": 0,
1710 "TT_STORAGE": 0, # #
1716 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1720 def command_ttname(name):
1721 """Set TT_NAME of selected ThingType."""
1722 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1726 def command_ttsymbol(char):
1727 """Set TT_SYMBOL of selected ThingType. """
1729 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1731 print("Ignoring: Argument must be single character.")
1735 def command_ttcorpseid(str_int):
1736 """Set TT_CORPSE_ID of selected ThingType."""
1737 val = integer_test(str_int, 0)
1739 if val in world_db["ThingTypes"]:
1740 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1742 print("Ignoring: Corpse ID belongs to no known ThignType.")
1745 def command_taid(id_string):
1746 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1748 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1750 id = id_setter(id_string, "ThingActions", command_taid, True)
1752 world_db["ThingActions"][id] = {
1758 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1761 @test_ThingAction_id
1762 def command_taname(name):
1763 """Set TA_NAME of selected ThingAction.
1765 The name must match a valid thing action function. If after the name
1766 setting no ThingAction with name "wait" remains, call set_world_inactive().
1768 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1769 or name == "pick_up":
1770 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1771 if 1 == world_db["WORLD_ACTIVE"]:
1772 wait_defined = False
1773 for id in world_db["ThingActions"]:
1774 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1777 if not wait_defined:
1778 set_world_inactive()
1780 print("Ignoring: Invalid action name.")
1781 # In contrast to the original,naming won't map a function to a ThingAction.
1785 """Call ai() on player Thing, then turn_over()."""
1786 ai(world_db["Things"][0])
1790 """Commands database.
1792 Map command start tokens to ([0]) number of expected command arguments, ([1])
1793 the command's meta-ness (i.e. is it to be written to the record file, is it to
1794 be ignored in replay mode if read from server input file), and ([2]) a function
1798 "QUIT": (0, True, command_quit),
1799 "PING": (0, True, command_ping),
1800 "THINGS_HERE": (2, True, command_thingshere),
1801 "MAKE_WORLD": (1, False, command_makeworld),
1802 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1803 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1804 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1805 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1806 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1807 "MAP_LENGTH": (1, False, command_maplength),
1808 "WORLD_ACTIVE": (1, False, command_worldactive),
1809 "MAP": (2, False, setter_map("MAP")),
1810 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
1811 "SLIPPERS": (1, False, command_slippers), # #
1812 "PLANT_0": (1, False, command_plant0), # #
1813 "TA_ID": (1, False, command_taid),
1814 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1815 "TA_NAME": (1, False, command_taname),
1816 "TT_ID": (1, False, command_ttid),
1817 "TT_NAME": (1, False, command_ttname),
1818 "TT_SYMBOL": (1, False, command_ttsymbol),
1819 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1820 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1822 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1824 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1826 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1827 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
1828 "T_ID": (1, False, command_tid),
1829 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1830 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1831 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1832 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1833 "T_COMMAND": (1, False, command_tcommand),
1834 "T_TYPE": (1, False, command_ttype),
1835 "T_CARRIES": (1, False, command_tcarries),
1836 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1837 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1838 "T_MEMTHING": (3, False, command_tmemthing),
1839 "T_POSY": (1, False, setter_tpos("Y")),
1840 "T_POSX": (1, False, setter_tpos("X")),
1841 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
1842 "wait": (0, False, play_commander("wait")),
1843 "move": (1, False, play_commander("move")),
1844 "pick_up": (0, False, play_commander("pick_up")),
1845 "drop": (1, False, play_commander("drop", True)),
1846 "use": (1, False, play_commander("use", True)),
1847 "ai": (0, False, command_ai)
1849 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1852 """World state database. With sane default values. (Randomness is in rand.)"""
1861 "FAVOR_STAGE": 0, # #
1869 """Mapping of direction names to internal direction chars."""
1870 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1871 "west": "s", "north-west": "w", "north-east": "e"}
1873 """File IO database."""
1875 "path_save": "save",
1876 "path_record": "record_save",
1877 "path_worldconf": "confserver/world",
1878 "path_server": "server/",
1879 "path_in": "server/in",
1880 "path_out": "server/out",
1881 "path_worldstate": "server/worldstate",
1882 "tmp_suffix": "_tmp",
1883 "kicked_by_rival": False,
1884 "worldstate_updateable": False
1889 libpr = prep_library()
1890 rand = RandomnessIO()
1891 opts = parse_command_line_arguments()
1893 io_db["path_save"] = opts.savefile
1894 io_db["path_record"] = "record_" + opts.savefile
1897 io_db["verbose"] = True
1898 if None != opts.replay:
1902 except SystemExit as exit:
1903 print("ABORTING: " + exit.args[0])
1905 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")