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()
103 """Send "msg" to log."""
104 strong_write(io_db["file_out"], "LOG " + msg + "\n")
107 def obey(command, prefix, replay=False, do_record=False):
108 """Call function from commands_db mapped to command's first token.
110 Tokenize command string with shlex.split(comments=True). If replay is set,
111 a non-meta command from the commands_db merely triggers obey() on the next
112 command from the records file. If not, non-meta commands set
113 io_db["worldstate_updateable"] to world_db["WORLD_ACTIVE"], and, if
114 do_record is set, are recorded to io_db["record_chunk"], and save_world()
115 is called (and io_db["record_chunk"] written) if 15 seconds have passed
116 since the last time it was called. The prefix string is inserted into the
117 server's input message between its beginning 'input ' and ':'. All activity
118 is preceded by a server_test() call. Commands that start with a lowercase
119 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
123 print("input " + prefix + ": " + command)
125 tokens = shlex.split(command, comments=True)
126 except ValueError as err:
127 print("Can't tokenize command string: " + str(err) + ".")
129 if len(tokens) > 0 and tokens[0] in commands_db \
130 and len(tokens) == commands_db[tokens[0]][0] + 1:
131 if commands_db[tokens[0]][1]:
132 commands_db[tokens[0]][2](*tokens[1:])
133 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
134 print("Ignoring lowercase-starting commands when world inactive.")
136 print("Due to replay mode, reading command as 'go on in record'.")
137 line = io_db["file_record"].readline()
139 obey(line.rstrip(), io_db["file_record"].prefix
140 + str(io_db["file_record"].line_n))
141 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
143 print("Reached end of record file.")
145 commands_db[tokens[0]][2](*tokens[1:])
147 io_db["record_chunk"] += command + "\n"
148 if time.time() > io_db["save_wait"] + 15:
149 atomic_write(io_db["path_record"], io_db["record_chunk"],
151 if world_db["WORLD_ACTIVE"]:
153 io_db["record_chunk"] = ""
154 io_db["save_wait"] = time.time()
155 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
156 elif 0 != len(tokens):
157 print("Invalid command/argument, or bad number of tokens.")
160 def atomic_write(path, text, do_append=False, delete=True):
161 """Atomic write of text to file at path, appended if do_append is set."""
162 path_tmp = path + io_db["tmp_suffix"]
166 if os.access(path, os.F_OK):
167 shutil.copyfile(path, path_tmp)
168 file = open(path_tmp, mode)
169 strong_write(file, text)
171 if delete and os.access(path, os.F_OK):
173 os.rename(path_tmp, path)
177 """Save all commands needed to reconstruct current world state."""
180 string = string.replace("\u005C", '\u005C\u005C')
181 return '"' + string.replace('"', '\u005C"') + '"'
186 if key == "MAP" or world_db["Things"][id][key]:
187 map = world_db["MAP"] if key == "MAP" \
188 else world_db["Things"][id][key]
189 length = world_db["MAP_LENGTH"]
190 for i in range(length):
191 line = map[i * length:(i * length) + length].decode()
192 string = string + key + " " + str(i) + " " + quote(line) \
199 for memthing in world_db["Things"][id]["T_MEMTHING"]:
200 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
201 str(memthing[1]) + " " + str(memthing[2]) + "\n"
204 def helper(category, id_string, special_keys={}):
206 for id in sorted(world_db[category].keys()):
207 string = string + id_string + " " + str(id) + "\n"
208 for key in sorted(world_db[category][id].keys()):
209 if not key in special_keys:
210 x = world_db[category][id][key]
211 argument = quote(x) if str == type(x) else str(x)
212 string = string + key + " " + argument + "\n"
213 elif special_keys[key]:
214 string = string + special_keys[key](id)
218 for key in sorted(world_db.keys()):
219 if (not isinstance(world_db[key], dict)) and key != "MAP" and \
220 key != "WORLD_ACTIVE":
221 string = string + key + " " + str(world_db[key]) + "\n"
222 string = string + mapsetter("MAP")()
223 string = string + helper("ThingActions", "TA_ID")
224 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
225 for id in sorted(world_db["ThingTypes"].keys()):
226 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
227 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
228 string = string + helper("Things", "T_ID",
229 {"T_CARRIES": False, "carried": False,
230 "T_MEMMAP": mapsetter("T_MEMMAP"),
231 "T_MEMTHING": memthing, "fovmap": False,
232 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
233 for id in sorted(world_db["Things"].keys()):
234 if [] != world_db["Things"][id]["T_CARRIES"]:
235 string = string + "T_ID " + str(id) + "\n"
236 for carried in sorted(world_db["Things"][id]["T_CARRIES"]):
237 string = string + "T_CARRIES " + str(carried) + "\n"
238 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
239 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
240 atomic_write(io_db["path_save"], string)
243 def obey_lines_in_file(path, name, do_record=False):
244 """Call obey() on each line of path's file, use name in input prefix."""
245 file = open(path, "r")
247 for line in file.readlines():
248 obey(line.rstrip(), name + "file line " + str(line_n),
254 def parse_command_line_arguments():
255 """Return settings values read from command line arguments."""
256 parser = argparse.ArgumentParser()
257 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
259 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
261 parser.add_argument('-v', dest='verbose', action='store_true')
262 opts, unknown = parser.parse_known_args()
267 """Ensure valid server out file belonging to current process.
269 This is done by comparing io_db["teststring"] to what's found at the start
270 of the current file at io_db["path_out"]. On failure, set
271 io_db["kicked_by_rival"] and raise SystemExit.
273 if not os.access(io_db["path_out"], os.F_OK):
274 raise SystemExit("Server output file has disappeared.")
275 file = open(io_db["path_out"], "r")
276 test = file.readline().rstrip("\n")
278 if test != io_db["teststring"]:
279 io_db["kicked_by_rival"] = True
280 msg = "Server test string in server output file does not match. This" \
281 " indicates that the current server process has been " \
282 "superseded by another one."
283 raise SystemExit(msg)
287 """Return next newline-delimited command from server in file.
289 Keep building return string until a newline is encountered. Pause between
290 unsuccessful reads, and after too much waiting, run server_test().
292 wait_on_fail = 0.03333
297 add = io_db["file_in"].readline()
299 command = command + add
300 if len(command) > 0 and "\n" == command[-1]:
301 command = command[:-1]
304 time.sleep(wait_on_fail)
305 if now + max_wait < time.time():
311 def try_worldstate_update():
312 """Write worldstate file if io_db["worldstate_updateable"] is set."""
313 if io_db["worldstate_updateable"]:
315 def write_map(string, map):
316 for i in range(length):
317 line = map[i * length:(i * length) + length].decode()
318 string = string + line + "\n"
322 if [] == world_db["Things"][0]["T_CARRIES"]:
323 inventory = "(none)\n"
325 for id in world_db["Things"][0]["T_CARRIES"]:
326 type_id = world_db["Things"][id]["T_TYPE"]
327 name = world_db["ThingTypes"][type_id]["TT_NAME"]
328 inventory = inventory + name + "\n"
329 string = str(world_db["TURN"]) + "\n" + \
330 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
331 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
332 inventory + "%\n" + \
333 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
334 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
335 str(world_db["MAP_LENGTH"]) + "\n"
336 length = world_db["MAP_LENGTH"]
337 fov = bytearray(b' ' * (length ** 2))
339 for pos in [pos for pos in range(length ** 2)
340 if ord_v == world_db["Things"][0]["fovmap"][pos]]:
341 fov[pos] = world_db["MAP"][pos]
342 length = world_db["MAP_LENGTH"]
343 for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
344 for id in world_db["Things"]
345 if not world_db["Things"][id]["carried"]
346 if world_db["Things"][id]["T_TYPE"] == tid
347 if world_db["Things"][0]["fovmap"][
348 world_db["Things"][id]["T_POSY"] * length
349 + world_db["Things"][id]["T_POSX"]] == ord_v]:
350 type = world_db["Things"][id]["T_TYPE"]
351 c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
352 fov[world_db["Things"][id]["T_POSY"] * length
353 + world_db["Things"][id]["T_POSX"]] = c
354 string = write_map(string, fov)
355 mem = world_db["Things"][0]["T_MEMMAP"][:]
356 for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
357 for mt in world_db["Things"][0]["T_MEMTHING"]
359 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
360 mem[(mt[1] * length) + mt[2]] = ord(c)
361 string = write_map(string, mem)
362 atomic_write(io_db["path_worldstate"], string, delete=False)
363 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
364 io_db["worldstate_updateable"] = False
368 """Replay game from record file.
370 Use opts.replay as breakpoint turn to which to replay automatically before
371 switching to manual input by non-meta commands in server input file
372 triggering further reads of record file. Ensure opts.replay is at least 1.
373 Run try_worldstate_update() before each interactive obey()/read_command().
377 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
378 " (if so late a turn is to be found).")
379 if not os.access(io_db["path_record"], os.F_OK):
380 raise SystemExit("No record file found to replay.")
381 io_db["file_record"] = open(io_db["path_record"], "r")
382 io_db["file_record"].prefix = "record file line "
383 io_db["file_record"].line_n = 1
384 while world_db["TURN"] < opts.replay:
385 line = io_db["file_record"].readline()
388 obey(line.rstrip(), io_db["file_record"].prefix
389 + str(io_db["file_record"].line_n))
390 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
392 try_worldstate_update()
393 obey(read_command(), "in file", replay=True)
397 """Play game by server input file commands. Before, load save file found.
399 If no save file is found, a new world is generated from the commands in the
400 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
401 command and all that follow via the server input file. Run
402 try_worldstate_update() before each interactive obey()/read_command().
404 if os.access(io_db["path_save"], os.F_OK):
405 obey_lines_in_file(io_db["path_save"], "save")
407 if not os.access(io_db["path_worldconf"], os.F_OK):
408 msg = "No world config file from which to start a new world."
409 raise SystemExit(msg)
410 obey_lines_in_file(io_db["path_worldconf"], "world config ",
412 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
414 try_worldstate_update()
415 obey(read_command(), "in file", do_record=True)
419 """(Re-)make island map.
421 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
422 start with one land cell in the middle, then go into cycle of repeatedly
423 selecting a random sea cell and transforming it into land if it is neighbor
424 to land. The cycle ends when a land cell is due to be created at the map's
425 border. Then put some trees on the map (TODO: more precise algorithm desc).
428 def is_neighbor(coordinates, type):
431 length = world_db["MAP_LENGTH"]
433 diag_west = x + (ind > 0)
434 diag_east = x + (ind < (length - 1))
435 pos = (y * length) + x
436 if (y > 0 and diag_east
437 and type == chr(world_db["MAP"][pos - length + ind])) \
439 and type == chr(world_db["MAP"][pos + 1])) \
440 or (y < (length - 1) and diag_east
441 and type == chr(world_db["MAP"][pos + length + ind])) \
442 or (y > 0 and diag_west
443 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
445 and type == chr(world_db["MAP"][pos - 1])) \
446 or (y < (length - 1) and diag_west
447 and type == chr(world_db["MAP"][pos + length - (not ind)])):
451 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
452 length = world_db["MAP_LENGTH"]
453 add_half_width = (not (length % 2)) * int(length / 2)
454 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
456 y = rand.next() % length
457 x = rand.next() % length
458 pos = (y * length) + x
459 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
460 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
462 world_db["MAP"][pos] = ord(".")
463 n_trees = int((length ** 2) / 16)
465 while (i_trees <= n_trees):
466 single_allowed = rand.next() % 32
467 y = rand.next() % length
468 x = rand.next() % length
469 pos = (y * length) + x
470 if "." == chr(world_db["MAP"][pos]) \
471 and ((not single_allowed) or is_neighbor((y, x), "X")):
472 world_db["MAP"][pos] = ord("X")
474 # This all-too-precise replica of the original C code misses iter_limit().
477 def update_map_memory(t, age_map=True):
478 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
480 def age_some_memdepthmap_on_nonfov_cells():
481 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
485 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
486 # if not ord_v == t["fovmap"][pos]
487 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
488 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
489 # if not rand.next() % (2 **
490 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
491 # t["T_MEMDEPTHMAP"][pos] += 1
492 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
493 fovmap = c_pointer_to_bytearray(t["fovmap"])
494 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
496 if not t["T_MEMMAP"]:
497 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
498 if not t["T_MEMDEPTHMAP"]:
499 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
502 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
503 if ord_v == t["fovmap"][pos]]:
504 t["T_MEMDEPTHMAP"][pos] = ord_0
505 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
507 age_some_memdepthmap_on_nonfov_cells()
508 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
509 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
511 for id in [id for id in world_db["Things"]
512 if not world_db["Things"][id]["carried"]]:
513 type = world_db["Things"][id]["T_TYPE"]
514 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
515 y = world_db["Things"][id]["T_POSY"]
516 x = world_db["Things"][id]["T_POSX"]
517 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
518 t["T_MEMTHING"].append((type, y, x))
521 def set_world_inactive():
522 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
524 if os.access(io_db["path_worldstate"], os.F_OK):
525 os.remove(io_db["path_worldstate"])
526 world_db["WORLD_ACTIVE"] = 0
529 def integer_test(val_string, min, max=None):
530 """Return val_string if integer >= min & (if max set) <= max, else None."""
532 val = int(val_string)
533 if val < min or (max is not None and val > max):
537 msg = "Ignoring: Please use integer >= " + str(min)
539 msg += " and <= " + str(max)
545 def setter(category, key, min, max=None):
546 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
549 val = integer_test(val_string, min, max)
553 if category == "Thing":
554 id_store = command_tid
555 decorator = test_Thing_id
556 elif category == "ThingType":
557 id_store = command_ttid
558 decorator = test_ThingType_id
559 elif category == "ThingAction":
560 id_store = command_taid
561 decorator = test_ThingAction_id
565 val = integer_test(val_string, min, max)
567 world_db[category + "s"][id_store.id][key] = val
571 def build_fov_map(t):
572 """Build Thing's FOV map."""
573 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
574 fovmap = c_pointer_to_bytearray(t["fovmap"])
575 map = c_pointer_to_bytearray(world_db["MAP"])
576 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
577 raise RuntimeError("Malloc error in build_fov_Map().")
581 """Send quick usage info to log."""
582 log("LOG See README file for help.")
585 def decrement_lifepoints(t):
586 """Decrement t's lifepoints by 1, and if to zero, corpse it.
588 If t is the player avatar, only blank its fovmap, so that the client may
589 still display memory data. On non-player things, erase fovmap and memory.
590 Dying actors drop all their things.
592 t["T_LIFEPOINTS"] -= 1
593 if 0 == t["T_LIFEPOINTS"]:
594 for id in t["T_CARRIES"]:
595 t["T_CARRIES"].remove(id)
596 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
597 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
598 world_db["Things"][id]["carried"] = False
599 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
600 if world_db["Things"][0] == t:
601 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
603 log("See README on how to start over.")
606 t["T_MEMMAP"] = False
607 t["T_MEMDEPTHMAP"] = False
611 def mv_yx_in_dir_legal(dir, y, x):
612 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
613 dir_c = dir.encode("ascii")[0]
614 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
616 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
617 return (test, libpr.result_y(), libpr.result_x())
621 """Make t do nothing (but loudly, if player avatar)."""
622 if t == world_db["Things"][0]:
627 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
629 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
630 t["T_POSY"], t["T_POSX"])
631 if 1 == move_result[0]:
632 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
633 hitted = [id for id in world_db["Things"]
634 if world_db["Things"][id] != t
635 if world_db["Things"][id]["T_LIFEPOINTS"]
636 if world_db["Things"][id]["T_POSY"] == move_result[1]
637 if world_db["Things"][id]["T_POSX"] == move_result[2]]
640 if t == world_db["Things"][0]:
641 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
642 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
643 log("You wound " + hitted_name + ".")
645 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
646 log(hitter_name +" wounds you.")
647 decrement_lifepoints(world_db["Things"][hit_id])
649 passable = "." == chr(world_db["MAP"][pos])
650 dir = [dir for dir in directions_db
651 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
653 t["T_POSY"] = move_result[1]
654 t["T_POSX"] = move_result[2]
655 for id in t["T_CARRIES"]:
656 world_db["Things"][id]["T_POSY"] = move_result[1]
657 world_db["Things"][id]["T_POSX"] = move_result[2]
659 if t == world_db["Things"][0]:
660 log("You move " + dir + ".")
661 elif t == world_db["Things"][0]:
662 log("You fail to move " + dir + ".")
665 def actor_pick_up(t):
666 """Make t pick up (topmost?) Thing from ground into inventory.
668 Define topmostness by how low the thing's type ID is.
670 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
671 if not world_db["Things"][id]["carried"]
672 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
673 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
677 tid = world_db["Things"][iid]["T_TYPE"]
678 if lowest_tid == -1 or tid < lowest_tid:
681 world_db["Things"][id]["carried"] = True
682 t["T_CARRIES"].append(id)
683 if t == world_db["Things"][0]:
684 log("You pick up an object.")
685 elif t == world_db["Things"][0]:
686 log("You try to pick up an object, but there is none.")
690 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
691 # TODO: Handle case where T_ARGUMENT matches nothing.
692 if len(t["T_CARRIES"]):
693 id = t["T_CARRIES"][t["T_ARGUMENT"]]
694 t["T_CARRIES"].remove(id)
695 world_db["Things"][id]["carried"] = False
696 if t == world_db["Things"][0]:
697 log("You drop an object.")
698 elif t == world_db["Things"][0]:
699 log("You try to drop an object, but you own none.")
703 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
704 # TODO: Handle case where T_ARGUMENT matches nothing.
705 if len(t["T_CARRIES"]):
706 id = t["T_CARRIES"][t["T_ARGUMENT"]]
707 type = world_db["Things"][id]["T_TYPE"]
708 if world_db["ThingTypes"][type]["TT_TOOL"] == "food":
709 t["T_CARRIES"].remove(id)
710 del world_db["Things"][id]
711 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
712 if t == world_db["Things"][0]:
713 log("You consume this object.")
714 elif t == world_db["Things"][0]:
715 log("You try to use this object, but fail.")
716 elif t == world_db["Things"][0]:
717 log("You try to use an object, but you own none.")
720 def thingproliferation(t, prol_map):
721 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
723 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
724 marked '.' in prol_map. If there are several map cell candidates, one is
727 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
728 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
730 for dir in [directions_db[key] for key in sorted(directions_db.keys())]:
731 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
732 if mv_result[0] and ord('.') == prol_map[mv_result[1]
733 * world_db["MAP_LENGTH"]
735 candidates.append((mv_result[1], mv_result[2]))
737 i = rand.next() % len(candidates)
738 id = id_setter(-1, "Things")
739 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
740 world_db["Things"][id] = newT
744 """If t's HP < max, increment them if well-nourished, maybe waiting."""
745 if t["T_LIFEPOINTS"] < \
746 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
747 wait_id = [id for id in world_db["ThingActions"]
748 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
749 wait_divider = 8 if t["T_COMMAND"] == wait_id else 1
750 testval = int(abs(t["T_SATIATION"]) / wait_divider)
751 if (testval <= 1 or 1 == (rand.next() % testval)):
752 t["T_LIFEPOINTS"] += 1
753 if t == world_db["Things"][0]:
757 def hunger_per_turn(type_id):
758 """The amount of satiation score lost per turn for things of given type."""
759 return int(math.sqrt(world_db["ThingTypes"][type_id]["TT_LIFEPOINTS"]))
763 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
764 if t["T_SATIATION"] > -32768:
765 t["T_SATIATION"] -= hunger_per_turn(t["T_TYPE"])
766 if 0 != t["T_SATIATION"] and 0 == int(rand.next() / abs(t["T_SATIATION"])):
767 if t == world_db["Things"][0]:
768 if t["T_SATIATION"] < 0:
769 log("You suffer from hunger.")
771 log("You suffer from over-eating.")
772 decrement_lifepoints(t)
775 def get_dir_to_target(t, filter):
776 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
778 The path-wise nearest target is chosen, via the shortest available path.
779 Target must not be t. On succcess, return positive value, else False.
781 "a": Thing in FOV is below a certain distance, animate, but of ThingType
782 that is not t's, and starts out weaker than t is; build path as
783 avoiding things of t's ThingType
784 "f": neighbor cell (not inhabited by any animate Thing) further away from
785 animate Thing not further than x steps away and in FOV and of a
786 ThingType that is not t's, and starts out stronger or as strong as t
787 is currently; or (cornered), if no such flight cell, but Thing of
788 above criteria is too near,1 a cell closer to it, or, if less near,
790 "c": Thing in memorized map is consumable
791 "s": memory map cell with greatest-reachable degree of unexploredness
794 def zero_score_map_where_char_on_memdepthmap(c):
795 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
796 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
797 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
798 # set_map_score(i, 0)
799 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
800 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
801 raise RuntimeError("No score map allocated for "
802 "zero_score_map_where_char_on_memdepthmap().")
804 def set_map_score(pos, score):
805 test = libpr.set_map_score(pos, score)
807 raise RuntimeError("No score map allocated for set_map_score().")
809 def get_map_score(pos):
810 result = libpr.get_map_score(pos)
812 raise RuntimeError("No score map allocated for get_map_score().")
816 if t["fovmap"] and ("a" == filter or "f" == filter):
817 for id in world_db["Things"]:
818 Thing = world_db["Things"][id]
819 if Thing != t and Thing["T_LIFEPOINTS"] and \
820 t["T_TYPE"] != Thing["T_TYPE"] and \
821 'v' == chr(t["fovmap"][(Thing["T_POSY"]
822 * world_db["MAP_LENGTH"])
824 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
825 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
827 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
830 elif t["T_MEMMAP"] and "c" == filter:
831 for mt in t["T_MEMTHING"]:
832 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
834 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
838 def set_cells_passable_on_memmap_to_65534_on_scoremap():
839 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
841 # memmap = t["T_MEMMAP"]
842 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
843 # if ord_dot == memmap[i]]:
844 # set_map_score(i, 65534) # i.e. 65535-1
845 map = c_pointer_to_bytearray(t["T_MEMMAP"])
846 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
847 raise RuntimeError("No score map allocated for set_cells_passable"
848 "_on_memmap_to_65534_on_scoremap().")
850 def init_score_map():
851 test = libpr.init_score_map()
853 raise RuntimeError("Malloc error in init_score_map().")
856 set_cells_passable_on_memmap_to_65534_on_scoremap()
858 for id in world_db["Things"]:
859 Thing = world_db["Things"][id]
860 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
862 if t != Thing and Thing["T_LIFEPOINTS"] and \
863 t["T_TYPE"] != Thing["T_TYPE"] and \
864 ord_v == t["fovmap"][pos] and \
865 t["T_LIFEPOINTS"] > \
866 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
867 set_map_score(pos, 0)
868 elif t["T_TYPE"] == Thing["T_TYPE"]:
869 set_map_score(pos, 65535)
871 for id in [id for id in world_db["Things"]
872 if world_db["Things"][id]["T_LIFEPOINTS"]]:
873 Thing = world_db["Things"][id]
874 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
876 if t["T_TYPE"] != Thing["T_TYPE"] and \
877 ord_v == t["fovmap"][pos] and \
878 t["T_LIFEPOINTS"] <= \
879 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
880 set_map_score(pos, 0)
882 for mt in [mt for mt in t["T_MEMTHING"]
883 if ord_blank != t["T_MEMMAP"][mt[1]
884 * world_db["MAP_LENGTH"]
886 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
887 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
889 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
891 def rand_target_dir(neighbors, cmp, dirs):
894 for i in range(len(dirs)):
895 if cmp == neighbors[i]:
896 candidates.append(dirs[i])
898 return candidates[rand.next() % n_candidates] if n_candidates else 0
900 def get_neighbor_scores(dirs, eye_pos):
902 if libpr.ready_neighbor_scores(eye_pos):
903 raise RuntimeError("No score map allocated for " +
904 "ready_neighbor_scores.()")
905 for i in range(len(dirs)):
906 scores.append(libpr.get_neighbor_score(i))
909 def get_dir_from_neighbors():
910 dir_to_target = False
912 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
913 neighbors = get_neighbor_scores(dirs, eye_pos)
915 inhabited = [world_db["Things"][id]["T_POSY"]
916 * world_db["MAP_LENGTH"]
917 + world_db["Things"][id]["T_POSX"]
918 for id in world_db["Things"]
919 if world_db["Things"][id]["T_LIFEPOINTS"]]
920 for i in range(len(dirs)):
921 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
922 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
924 for pos in [pos for pos in inhabited if pos == pos_cmp]:
927 minmax_start = 0 if "f" == filter else 65535 - 1
928 minmax_neighbor = minmax_start
929 for i in range(len(dirs)):
930 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
931 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
932 or ("f" != filter and minmax_neighbor > neighbors[i]):
933 minmax_neighbor = neighbors[i]
934 if minmax_neighbor != minmax_start:
935 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
937 if not dir_to_target:
938 if 1 == get_map_score(eye_pos):
939 dir_to_target = rand_target_dir(neighbors, 0, dirs)
940 elif 3 >= get_map_score(eye_pos):
941 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
943 world_db["ThingActions"][id]["TA_NAME"]
946 elif dir_to_target and 3 < get_map_score(eye_pos):
948 elif "a" == filter and 10 <= get_map_score(eye_pos):
952 dir_to_target = False
954 run_i = 9 + 1 if "s" == filter else 1
955 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
958 mem_depth_c = b'9' if b' ' == mem_depth_c \
959 else bytes([mem_depth_c[0] - 1])
960 if libpr.dijkstra_map():
961 raise RuntimeError("No score map allocated for dijkstra_map().")
962 dir_to_target = get_dir_from_neighbors()
963 libpr.free_score_map()
964 if dir_to_target and str == type(dir_to_target):
965 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
966 if world_db["ThingActions"][id]["TA_NAME"]
968 t["T_ARGUMENT"] = ord(dir_to_target)
972 def standing_on_food(t):
973 """Return True/False whether t is standing on a consumable."""
974 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
975 if not world_db["Things"][id]["carried"]
976 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
977 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
978 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
979 ["TT_TOOL"] == "food"]:
984 def get_inventory_slot_to_consume(t):
985 """Return invent. slot of healthiest consumable(if any healthy),else -1."""
989 hunger_u = hunger_per_turn(t["T_TYPE"])
990 type = [id for id in world_db["ThingActions"]
991 if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
992 consume_hungering = world_db["ThingActions"][type]["TA_EFFORT"] * hunger_u
993 for id in t["T_CARRIES"]:
994 type = world_db["Things"][id]["T_TYPE"]
995 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
996 and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
997 nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
998 tmp_cmp = abs(t["T_SATIATION"] + nutvalue - consume_hungering)
999 if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1000 or (cmp_food < 0 and 0 > t["T_SATIATION"] + nutvalue) \
1001 or tmp_cmp < cmp_food:
1009 """Determine next command/argment for actor t via AI algorithms.
1011 AI will look for, and move towards, enemies (animate Things not of their
1012 own ThingType); if they see none, they will consume consumables in their
1013 inventory; if there are none, they will pick up what they stand on if they
1014 stand on consumables; if they stand on none, they will move towards the
1015 next consumable they see or remember on the map; if they see or remember
1016 none, they will explore parts of the map unseen since ever or for at least
1017 one turn; if there is nothing to explore, they will simply wait.
1019 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1020 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1021 if not get_dir_to_target(t, "f"):
1022 sel = get_inventory_slot_to_consume(t)
1024 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1025 if world_db["ThingActions"][id]["TA_NAME"]
1027 t["T_ARGUMENT"] = sel
1028 elif standing_on_food(t):
1029 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1030 if world_db["ThingActions"][id]["TA_NAME"]
1032 elif (not get_dir_to_target(t, "c")) and \
1033 (not get_dir_to_target(t, "a")):
1034 get_dir_to_target(t, "s")
1038 """Run game world and its inhabitants until new player input expected."""
1040 whilebreaker = False
1041 while world_db["Things"][0]["T_LIFEPOINTS"]:
1042 proliferable_map = world_db["MAP"][:]
1043 for id in [id for id in world_db["Things"]
1044 if not world_db["Things"][id]["carried"]]:
1045 y = world_db["Things"][id]["T_POSY"]
1046 x = world_db["Things"][id]["T_POSX"]
1047 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1048 for id in [id for id in world_db["Things"]]: # Only what's from start!
1049 if not id in world_db["Things"] or \
1050 world_db["Things"][id]["carried"]: # May have been consumed or
1051 continue # picked up during turn …
1052 Thing = world_db["Things"][id]
1053 if Thing["T_LIFEPOINTS"]:
1054 if not Thing["T_COMMAND"]:
1055 update_map_memory(Thing)
1062 if Thing["T_LIFEPOINTS"]:
1063 Thing["T_PROGRESS"] += 1
1064 taid = [a for a in world_db["ThingActions"]
1065 if a == Thing["T_COMMAND"]][0]
1066 ThingAction = world_db["ThingActions"][taid]
1067 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1068 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1069 Thing["T_COMMAND"] = 0
1070 Thing["T_PROGRESS"] = 0
1071 thingproliferation(Thing, proliferable_map)
1074 world_db["TURN"] += 1
1077 def new_Thing(type, pos=(0, 0)):
1078 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1080 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1092 "T_MEMDEPTHMAP": False,
1095 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1096 build_fov_map(thing)
1100 def id_setter(id, category, id_store=False, start_at_1=False):
1101 """Set ID of object of category to manipulate ID unused? Create new one.
1102 The ID is stored as id_store.id (if id_store is set). If the integer of the
1103 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1104 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1105 always returned when no new object is created, else the new object's ID.
1107 min = 0 if start_at_1 else -1
1109 id = integer_test(id, min)
1111 if id in world_db[category]:
1116 if (start_at_1 and 0 == id) \
1117 or ((not start_at_1) and (id < 0)):
1118 id = 0 if start_at_1 else -1
1121 if id not in world_db[category]:
1129 """Send PONG line to server output file."""
1130 strong_write(io_db["file_out"], "PONG\n")
1134 """Abort server process."""
1135 if None == opts.replay:
1136 if world_db["WORLD_ACTIVE"]:
1138 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1139 raise SystemExit("received QUIT command")
1142 def command_thingshere(str_y, str_x):
1143 """Write to out file list of Things known to player at coordinate y, x."""
1144 if world_db["WORLD_ACTIVE"]:
1145 y = integer_test(str_y, 0, 255)
1146 x = integer_test(str_x, 0, 255)
1147 length = world_db["MAP_LENGTH"]
1148 if None != y and None != x and y < length and x < length:
1149 pos = (y * world_db["MAP_LENGTH"]) + x
1150 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1151 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1152 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1153 for id in world_db["Things"]
1154 if not world_db["Things"][id]["carried"]
1155 if world_db["Things"][id]["T_TYPE"] == tid
1156 if y == world_db["Things"][id]["T_POSY"]
1157 if x == world_db["Things"][id]["T_POSX"]]:
1158 type = world_db["Things"][id]["T_TYPE"]
1159 name = world_db["ThingTypes"][type]["TT_NAME"]
1160 strong_write(io_db["file_out"], name + "\n")
1162 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1163 for mt in world_db["Things"][0]["T_MEMTHING"]
1164 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1165 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1166 strong_write(io_db["file_out"], name + "\n")
1167 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1169 print("Ignoring: Invalid map coordinates.")
1171 print("Ignoring: Command only works on existing worlds.")
1174 def play_commander(action, args=False):
1175 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1177 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1181 id = [x for x in world_db["ThingActions"]
1182 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1183 world_db["Things"][0]["T_COMMAND"] = id
1186 def set_command_and_argument_int(str_arg):
1187 val = integer_test(str_arg, 0, 255)
1189 world_db["Things"][0]["T_ARGUMENT"] = val
1192 def set_command_and_argument_movestring(str_arg):
1193 if str_arg in directions_db:
1194 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1197 print("Ignoring: Argument must be valid direction string.")
1199 if action == "move":
1200 return set_command_and_argument_movestring
1202 return set_command_and_argument_int
1207 def command_seedrandomness(seed_string):
1208 """Set rand seed to int(seed_string)."""
1209 val = integer_test(seed_string, 0, 4294967295)
1214 def command_makeworld(seed_string):
1215 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1217 Seed rand with seed. Do more only with a "wait" ThingAction and
1218 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1219 world_db["Things"] emptied, call make_map() and set
1220 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1221 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1222 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1223 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1230 err = "Space to put thing on too hard to find. Map too small?"
1232 y = rand.next() % world_db["MAP_LENGTH"]
1233 x = rand.next() % world_db["MAP_LENGTH"]
1234 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1238 raise SystemExit(err)
1239 # Replica of C code, wrongly ignores animatedness of new Thing.
1240 pos_clear = (0 == len([id for id in world_db["Things"]
1241 if world_db["Things"][id]["T_LIFEPOINTS"]
1242 if world_db["Things"][id]["T_POSY"] == y
1243 if world_db["Things"][id]["T_POSX"] == x]))
1248 val = integer_test(seed_string, 0, 4294967295)
1252 player_will_be_generated = False
1253 playertype = world_db["PLAYER_TYPE"]
1254 for ThingType in world_db["ThingTypes"]:
1255 if playertype == ThingType:
1256 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1257 player_will_be_generated = True
1259 if not player_will_be_generated:
1260 print("Ignoring: No player type with start number >0 defined.")
1263 for ThingAction in world_db["ThingActions"]:
1264 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1267 print("Ignoring beyond SEED_MAP: " +
1268 "No thing action with name 'wait' defined.")
1270 world_db["Things"] = {}
1272 world_db["WORLD_ACTIVE"] = 1
1273 world_db["TURN"] = 1
1274 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1275 id = id_setter(-1, "Things")
1276 world_db["Things"][id] = new_Thing(playertype, free_pos())
1277 if not world_db["Things"][0]["fovmap"]:
1278 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1279 world_db["Things"][0]["fovmap"] = empty_fovmap
1280 update_map_memory(world_db["Things"][0])
1281 for type in world_db["ThingTypes"]:
1282 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1283 if type != playertype:
1284 id = id_setter(-1, "Things")
1285 world_db["Things"][id] = new_Thing(type, free_pos())
1286 strong_write(io_db["file_out"], "NEW_WORLD\n")
1290 def command_maplength(maplength_string):
1291 """Redefine map length. Invalidate map, therefore lose all things on it."""
1292 val = integer_test(maplength_string, 1, 256)
1294 world_db["MAP_LENGTH"] = val
1295 world_db["MAP"] = False
1296 set_world_inactive()
1297 world_db["Things"] = {}
1298 libpr.set_maplength(val)
1301 def command_worldactive(worldactive_string):
1302 """Toggle world_db["WORLD_ACTIVE"] if possible.
1304 An active world can always be set inactive. An inactive world can only be
1305 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1306 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1307 Also call log_help().
1309 val = integer_test(worldactive_string, 0, 1)
1311 if 0 != world_db["WORLD_ACTIVE"]:
1313 set_world_inactive()
1315 print("World already active.")
1316 elif 0 == world_db["WORLD_ACTIVE"]:
1318 for ThingAction in world_db["ThingActions"]:
1319 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1322 player_exists = False
1323 for Thing in world_db["Things"]:
1325 player_exists = True
1327 if wait_exists and player_exists and world_db["MAP"]:
1328 for id in world_db["Things"]:
1329 if world_db["Things"][id]["T_LIFEPOINTS"]:
1330 build_fov_map(world_db["Things"][id])
1332 update_map_memory(world_db["Things"][id], False)
1333 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1334 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1335 world_db["Things"][0]["fovmap"] = empty_fovmap
1336 world_db["WORLD_ACTIVE"] = 1
1339 print("Ignoring: Not all conditions for world activation met.")
1342 def test_for_id_maker(object, category):
1343 """Return decorator testing for object having "id" attribute."""
1346 if hasattr(object, "id"):
1349 print("Ignoring: No " + category +
1350 " defined to manipulate yet.")
1355 def command_tid(id_string):
1356 """Set ID of Thing to manipulate. ID unused? Create new one.
1358 Default new Thing's type to the first available ThingType, others: zero.
1360 id = id_setter(id_string, "Things", command_tid)
1362 if world_db["ThingTypes"] == {}:
1363 print("Ignoring: No ThingType to settle new Thing in.")
1365 type = list(world_db["ThingTypes"].keys())[0]
1366 world_db["Things"][id] = new_Thing(type)
1369 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1373 def command_tcommand(str_int):
1374 """Set T_COMMAND of selected Thing."""
1375 val = integer_test(str_int, 0)
1377 if 0 == val or val in world_db["ThingActions"]:
1378 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1380 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1384 def command_ttype(str_int):
1385 """Set T_TYPE of selected Thing."""
1386 val = integer_test(str_int, 0)
1388 if val in world_db["ThingTypes"]:
1389 world_db["Things"][command_tid.id]["T_TYPE"] = val
1391 print("Ignoring: ThingType ID belongs to no known ThingType.")
1395 def command_tcarries(str_int):
1396 """Append int(str_int) to T_CARRIES of selected Thing.
1398 The ID int(str_int) must not be of the selected Thing, and must belong to a
1399 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1401 val = integer_test(str_int, 0)
1403 if val == command_tid.id:
1404 print("Ignoring: Thing cannot carry itself.")
1405 elif val in world_db["Things"] \
1406 and not world_db["Things"][val]["carried"]:
1407 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1408 world_db["Things"][val]["carried"] = True
1410 print("Ignoring: Thing not available for carrying.")
1411 # Note that the whole carrying structure is different from the C version:
1412 # Carried-ness is marked by a "carried" flag, not by Things containing
1413 # Things internally.
1417 def command_tmemthing(str_t, str_y, str_x):
1418 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1420 The type must fit to an existing ThingType, and the position into the map.
1422 type = integer_test(str_t, 0)
1423 posy = integer_test(str_y, 0, 255)
1424 posx = integer_test(str_x, 0, 255)
1425 if None != type and None != posy and None != posx:
1426 if type not in world_db["ThingTypes"] \
1427 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1428 print("Ignoring: Illegal value for thing type or position.")
1430 memthing = (type, posy, posx)
1431 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1434 def setter_map(maptype):
1435 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1437 If no map of maptype exists yet, initialize it with ' ' bytes first.
1440 def valid_map_line(str_int, mapline):
1441 val = integer_test(str_int, 0, 255)
1443 if val >= world_db["MAP_LENGTH"]:
1444 print("Illegal value for map line number.")
1445 elif len(mapline) != world_db["MAP_LENGTH"]:
1446 print("Map line length is unequal map width.")
1451 def nonThingMap_helper(str_int, mapline):
1452 val = valid_map_line(str_int, mapline)
1454 length = world_db["MAP_LENGTH"]
1455 if not world_db["MAP"]:
1456 map = bytearray(b' ' * (length ** 2))
1458 map = world_db["MAP"]
1459 map[val * length:(val * length) + length] = mapline.encode()
1460 if not world_db["MAP"]:
1461 world_db["MAP"] = map
1464 def ThingMap_helper(str_int, mapline):
1465 val = valid_map_line(str_int, mapline)
1467 length = world_db["MAP_LENGTH"]
1468 if not world_db["Things"][command_tid.id][maptype]:
1469 map = bytearray(b' ' * (length ** 2))
1471 map = world_db["Things"][command_tid.id][maptype]
1472 map[val * length:(val * length) + length] = mapline.encode()
1473 if not world_db["Things"][command_tid.id][maptype]:
1474 world_db["Things"][command_tid.id][maptype] = map
1476 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1480 def setter_tpos(axis):
1481 """Generate setter for T_POSX or T_POSY of selected Thing.
1483 If world is active, rebuilds animate things' fovmap, player's memory map.
1486 def helper(str_int):
1487 val = integer_test(str_int, 0, 255)
1489 if val < world_db["MAP_LENGTH"]:
1490 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1491 if world_db["WORLD_ACTIVE"] \
1492 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1493 build_fov_map(world_db["Things"][command_tid.id])
1494 if 0 == command_tid.id:
1495 update_map_memory(world_db["Things"][command_tid.id])
1497 print("Ignoring: Position is outside of map.")
1501 def command_ttid(id_string):
1502 """Set ID of ThingType to manipulate. ID unused? Create new one.
1504 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1507 id = id_setter(id_string, "ThingTypes", command_ttid)
1509 world_db["ThingTypes"][id] = {
1510 "TT_NAME": "(none)",
1513 "TT_PROLIFERATE": 0,
1514 "TT_START_NUMBER": 0,
1521 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1525 def command_ttname(name):
1526 """Set TT_NAME of selected ThingType."""
1527 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1531 def command_tttool(name):
1532 """Set TT_TOOL of selected ThingType."""
1533 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1537 def command_ttsymbol(char):
1538 """Set TT_SYMBOL of selected ThingType. """
1540 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1542 print("Ignoring: Argument must be single character.")
1546 def command_ttcorpseid(str_int):
1547 """Set TT_CORPSE_ID of selected ThingType."""
1548 val = integer_test(str_int, 0)
1550 if val in world_db["ThingTypes"]:
1551 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1553 print("Ignoring: Corpse ID belongs to no known ThignType.")
1556 def command_taid(id_string):
1557 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1559 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1561 id = id_setter(id_string, "ThingActions", command_taid, True)
1563 world_db["ThingActions"][id] = {
1569 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1572 @test_ThingAction_id
1573 def command_taname(name):
1574 """Set TA_NAME of selected ThingAction.
1576 The name must match a valid thing action function. If after the name
1577 setting no ThingAction with name "wait" remains, call set_world_inactive().
1579 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1580 or name == "pick_up":
1581 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1582 if 1 == world_db["WORLD_ACTIVE"]:
1583 wait_defined = False
1584 for id in world_db["ThingActions"]:
1585 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1588 if not wait_defined:
1589 set_world_inactive()
1591 print("Ignoring: Invalid action name.")
1592 # In contrast to the original,naming won't map a function to a ThingAction.
1596 """Call ai() on player Thing, then turn_over()."""
1597 ai(world_db["Things"][0])
1601 """Commands database.
1603 Map command start tokens to ([0]) number of expected command arguments, ([1])
1604 the command's meta-ness (i.e. is it to be written to the record file, is it to
1605 be ignored in replay mode if read from server input file), and ([2]) a function
1609 "QUIT": (0, True, command_quit),
1610 "PING": (0, True, command_ping),
1611 "THINGS_HERE": (2, True, command_thingshere),
1612 "MAKE_WORLD": (1, False, command_makeworld),
1613 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1614 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1615 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1616 "MAP_LENGTH": (1, False, command_maplength),
1617 "WORLD_ACTIVE": (1, False, command_worldactive),
1618 "MAP": (2, False, setter_map("MAP")),
1619 "TA_ID": (1, False, command_taid),
1620 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1621 "TA_NAME": (1, False, command_taname),
1622 "TT_ID": (1, False, command_ttid),
1623 "TT_NAME": (1, False, command_ttname),
1624 "TT_TOOL": (1, False, command_tttool),
1625 "TT_SYMBOL": (1, False, command_ttsymbol),
1626 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1627 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1628 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1630 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1632 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1633 "T_ID": (1, False, command_tid),
1634 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1635 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1636 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1637 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1638 "T_COMMAND": (1, False, command_tcommand),
1639 "T_TYPE": (1, False, command_ttype),
1640 "T_CARRIES": (1, False, command_tcarries),
1641 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1642 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1643 "T_MEMTHING": (3, False, command_tmemthing),
1644 "T_POSY": (1, False, setter_tpos("Y")),
1645 "T_POSX": (1, False, setter_tpos("X")),
1646 "wait": (0, False, play_commander("wait")),
1647 "move": (1, False, play_commander("move")),
1648 "pick_up": (0, False, play_commander("pick_up")),
1649 "drop": (1, False, play_commander("drop", True)),
1650 "use": (1, False, play_commander("use", True)),
1651 "ai": (0, False, command_ai)
1653 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1656 """World state database. With sane default values. (Randomness is in rand.)"""
1668 """Mapping of direction names to internal direction chars."""
1669 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1670 "west": "s", "north-west": "w", "north-east": "e"}
1672 """File IO database."""
1674 "path_save": "save",
1675 "path_record": "record_save",
1676 "path_worldconf": "confserver/world",
1677 "path_server": "server/",
1678 "path_in": "server/in",
1679 "path_out": "server/out",
1680 "path_worldstate": "server/worldstate",
1681 "tmp_suffix": "_tmp",
1682 "kicked_by_rival": False,
1683 "worldstate_updateable": False
1688 libpr = prep_library()
1689 rand = RandomnessIO()
1690 opts = parse_command_line_arguments()
1692 io_db["path_save"] = opts.savefile
1693 io_db["path_record"] = "record_" + opts.savefile
1696 io_db["verbose"] = True
1697 if None != opts.replay:
1701 except SystemExit as exit:
1702 print("ABORTING: " + exit.args[0])
1704 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")