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 tmp_cmp < cmp_food:
1008 """Determine next command/argment for actor t via AI algorithms.
1010 AI will look for, and move towards, enemies (animate Things not of their
1011 own ThingType); if they see none, they will consume consumables in their
1012 inventory; if there are none, they will pick up what they stand on if they
1013 stand on consumables; if they stand on none, they will move towards the
1014 next consumable they see or remember on the map; if they see or remember
1015 none, they will explore parts of the map unseen since ever or for at least
1016 one turn; if there is nothing to explore, they will simply wait.
1018 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1019 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1020 if not get_dir_to_target(t, "f"):
1021 sel = get_inventory_slot_to_consume(t)
1023 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1024 if world_db["ThingActions"][id]["TA_NAME"]
1026 t["T_ARGUMENT"] = sel
1027 elif standing_on_food(t):
1028 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1029 if world_db["ThingActions"][id]["TA_NAME"]
1031 elif (not get_dir_to_target(t, "c")) and \
1032 (not get_dir_to_target(t, "a")):
1033 get_dir_to_target(t, "s")
1037 """Run game world and its inhabitants until new player input expected."""
1039 whilebreaker = False
1040 while world_db["Things"][0]["T_LIFEPOINTS"]:
1041 proliferable_map = world_db["MAP"][:]
1042 for id in [id for id in world_db["Things"]
1043 if not world_db["Things"][id]["carried"]]:
1044 y = world_db["Things"][id]["T_POSY"]
1045 x = world_db["Things"][id]["T_POSX"]
1046 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1047 for id in [id for id in world_db["Things"]]: # Only what's from start!
1048 if not id in world_db["Things"] or \
1049 world_db["Things"][id]["carried"]: # May have been consumed or
1050 continue # picked up during turn …
1051 Thing = world_db["Things"][id]
1052 if Thing["T_LIFEPOINTS"]:
1053 if not Thing["T_COMMAND"]:
1054 update_map_memory(Thing)
1061 if Thing["T_LIFEPOINTS"]:
1062 Thing["T_PROGRESS"] += 1
1063 taid = [a for a in world_db["ThingActions"]
1064 if a == Thing["T_COMMAND"]][0]
1065 ThingAction = world_db["ThingActions"][taid]
1066 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1067 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1068 Thing["T_COMMAND"] = 0
1069 Thing["T_PROGRESS"] = 0
1070 thingproliferation(Thing, proliferable_map)
1073 world_db["TURN"] += 1
1076 def new_Thing(type, pos=(0, 0)):
1077 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1079 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1091 "T_MEMDEPTHMAP": False,
1094 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1095 build_fov_map(thing)
1099 def id_setter(id, category, id_store=False, start_at_1=False):
1100 """Set ID of object of category to manipulate ID unused? Create new one.
1101 The ID is stored as id_store.id (if id_store is set). If the integer of the
1102 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1103 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1104 always returned when no new object is created, else the new object's ID.
1106 min = 0 if start_at_1 else -1
1108 id = integer_test(id, min)
1110 if id in world_db[category]:
1115 if (start_at_1 and 0 == id) \
1116 or ((not start_at_1) and (id < 0)):
1117 id = 0 if start_at_1 else -1
1120 if id not in world_db[category]:
1128 """Send PONG line to server output file."""
1129 strong_write(io_db["file_out"], "PONG\n")
1133 """Abort server process."""
1134 if None == opts.replay:
1135 if world_db["WORLD_ACTIVE"]:
1137 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1138 raise SystemExit("received QUIT command")
1141 def command_thingshere(str_y, str_x):
1142 """Write to out file list of Things known to player at coordinate y, x."""
1143 if world_db["WORLD_ACTIVE"]:
1144 y = integer_test(str_y, 0, 255)
1145 x = integer_test(str_x, 0, 255)
1146 length = world_db["MAP_LENGTH"]
1147 if None != y and None != x and y < length and x < length:
1148 pos = (y * world_db["MAP_LENGTH"]) + x
1149 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1150 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1151 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1152 for id in world_db["Things"]
1153 if not world_db["Things"][id]["carried"]
1154 if world_db["Things"][id]["T_TYPE"] == tid
1155 if y == world_db["Things"][id]["T_POSY"]
1156 if x == world_db["Things"][id]["T_POSX"]]:
1157 type = world_db["Things"][id]["T_TYPE"]
1158 name = world_db["ThingTypes"][type]["TT_NAME"]
1159 strong_write(io_db["file_out"], name + "\n")
1161 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1162 for mt in world_db["Things"][0]["T_MEMTHING"]
1163 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1164 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1165 strong_write(io_db["file_out"], name + "\n")
1166 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1168 print("Ignoring: Invalid map coordinates.")
1170 print("Ignoring: Command only works on existing worlds.")
1173 def play_commander(action, args=False):
1174 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1176 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1180 id = [x for x in world_db["ThingActions"]
1181 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1182 world_db["Things"][0]["T_COMMAND"] = id
1185 def set_command_and_argument_int(str_arg):
1186 val = integer_test(str_arg, 0, 255)
1188 world_db["Things"][0]["T_ARGUMENT"] = val
1191 def set_command_and_argument_movestring(str_arg):
1192 if str_arg in directions_db:
1193 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1196 print("Ignoring: Argument must be valid direction string.")
1198 if action == "move":
1199 return set_command_and_argument_movestring
1201 return set_command_and_argument_int
1206 def command_seedrandomness(seed_string):
1207 """Set rand seed to int(seed_string)."""
1208 val = integer_test(seed_string, 0, 4294967295)
1213 def command_makeworld(seed_string):
1214 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1216 Seed rand with seed. Do more only with a "wait" ThingAction and
1217 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1218 world_db["Things"] emptied, call make_map() and set
1219 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1220 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1221 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1222 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1229 err = "Space to put thing on too hard to find. Map too small?"
1231 y = rand.next() % world_db["MAP_LENGTH"]
1232 x = rand.next() % world_db["MAP_LENGTH"]
1233 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1237 raise SystemExit(err)
1238 # Replica of C code, wrongly ignores animatedness of new Thing.
1239 pos_clear = (0 == len([id for id in world_db["Things"]
1240 if world_db["Things"][id]["T_LIFEPOINTS"]
1241 if world_db["Things"][id]["T_POSY"] == y
1242 if world_db["Things"][id]["T_POSX"] == x]))
1247 val = integer_test(seed_string, 0, 4294967295)
1251 player_will_be_generated = False
1252 playertype = world_db["PLAYER_TYPE"]
1253 for ThingType in world_db["ThingTypes"]:
1254 if playertype == ThingType:
1255 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1256 player_will_be_generated = True
1258 if not player_will_be_generated:
1259 print("Ignoring: No player type with start number >0 defined.")
1262 for ThingAction in world_db["ThingActions"]:
1263 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1266 print("Ignoring beyond SEED_MAP: " +
1267 "No thing action with name 'wait' defined.")
1269 world_db["Things"] = {}
1271 world_db["WORLD_ACTIVE"] = 1
1272 world_db["TURN"] = 1
1273 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1274 id = id_setter(-1, "Things")
1275 world_db["Things"][id] = new_Thing(playertype, free_pos())
1276 if not world_db["Things"][0]["fovmap"]:
1277 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1278 world_db["Things"][0]["fovmap"] = empty_fovmap
1279 update_map_memory(world_db["Things"][0])
1280 for type in world_db["ThingTypes"]:
1281 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1282 if type != playertype:
1283 id = id_setter(-1, "Things")
1284 world_db["Things"][id] = new_Thing(type, free_pos())
1285 strong_write(io_db["file_out"], "NEW_WORLD\n")
1289 def command_maplength(maplength_string):
1290 """Redefine map length. Invalidate map, therefore lose all things on it."""
1291 val = integer_test(maplength_string, 1, 256)
1293 world_db["MAP_LENGTH"] = val
1294 world_db["MAP"] = False
1295 set_world_inactive()
1296 world_db["Things"] = {}
1297 libpr.set_maplength(val)
1300 def command_worldactive(worldactive_string):
1301 """Toggle world_db["WORLD_ACTIVE"] if possible.
1303 An active world can always be set inactive. An inactive world can only be
1304 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1305 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1306 Also call log_help().
1308 val = integer_test(worldactive_string, 0, 1)
1310 if 0 != world_db["WORLD_ACTIVE"]:
1312 set_world_inactive()
1314 print("World already active.")
1315 elif 0 == world_db["WORLD_ACTIVE"]:
1317 for ThingAction in world_db["ThingActions"]:
1318 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1321 player_exists = False
1322 for Thing in world_db["Things"]:
1324 player_exists = True
1326 if wait_exists and player_exists and world_db["MAP"]:
1327 for id in world_db["Things"]:
1328 if world_db["Things"][id]["T_LIFEPOINTS"]:
1329 build_fov_map(world_db["Things"][id])
1331 update_map_memory(world_db["Things"][id], False)
1332 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1333 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1334 world_db["Things"][0]["fovmap"] = empty_fovmap
1335 world_db["WORLD_ACTIVE"] = 1
1338 print("Ignoring: Not all conditions for world activation met.")
1341 def test_for_id_maker(object, category):
1342 """Return decorator testing for object having "id" attribute."""
1345 if hasattr(object, "id"):
1348 print("Ignoring: No " + category +
1349 " defined to manipulate yet.")
1354 def command_tid(id_string):
1355 """Set ID of Thing to manipulate. ID unused? Create new one.
1357 Default new Thing's type to the first available ThingType, others: zero.
1359 id = id_setter(id_string, "Things", command_tid)
1361 if world_db["ThingTypes"] == {}:
1362 print("Ignoring: No ThingType to settle new Thing in.")
1364 type = list(world_db["ThingTypes"].keys())[0]
1365 world_db["Things"][id] = new_Thing(type)
1368 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1372 def command_tcommand(str_int):
1373 """Set T_COMMAND of selected Thing."""
1374 val = integer_test(str_int, 0)
1376 if 0 == val or val in world_db["ThingActions"]:
1377 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1379 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1383 def command_ttype(str_int):
1384 """Set T_TYPE of selected Thing."""
1385 val = integer_test(str_int, 0)
1387 if val in world_db["ThingTypes"]:
1388 world_db["Things"][command_tid.id]["T_TYPE"] = val
1390 print("Ignoring: ThingType ID belongs to no known ThingType.")
1394 def command_tcarries(str_int):
1395 """Append int(str_int) to T_CARRIES of selected Thing.
1397 The ID int(str_int) must not be of the selected Thing, and must belong to a
1398 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1400 val = integer_test(str_int, 0)
1402 if val == command_tid.id:
1403 print("Ignoring: Thing cannot carry itself.")
1404 elif val in world_db["Things"] \
1405 and not world_db["Things"][val]["carried"]:
1406 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1407 world_db["Things"][val]["carried"] = True
1409 print("Ignoring: Thing not available for carrying.")
1410 # Note that the whole carrying structure is different from the C version:
1411 # Carried-ness is marked by a "carried" flag, not by Things containing
1412 # Things internally.
1416 def command_tmemthing(str_t, str_y, str_x):
1417 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1419 The type must fit to an existing ThingType, and the position into the map.
1421 type = integer_test(str_t, 0)
1422 posy = integer_test(str_y, 0, 255)
1423 posx = integer_test(str_x, 0, 255)
1424 if None != type and None != posy and None != posx:
1425 if type not in world_db["ThingTypes"] \
1426 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1427 print("Ignoring: Illegal value for thing type or position.")
1429 memthing = (type, posy, posx)
1430 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1433 def setter_map(maptype):
1434 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1436 If no map of maptype exists yet, initialize it with ' ' bytes first.
1439 def valid_map_line(str_int, mapline):
1440 val = integer_test(str_int, 0, 255)
1442 if val >= world_db["MAP_LENGTH"]:
1443 print("Illegal value for map line number.")
1444 elif len(mapline) != world_db["MAP_LENGTH"]:
1445 print("Map line length is unequal map width.")
1450 def nonThingMap_helper(str_int, mapline):
1451 val = valid_map_line(str_int, mapline)
1453 length = world_db["MAP_LENGTH"]
1454 if not world_db["MAP"]:
1455 map = bytearray(b' ' * (length ** 2))
1457 map = world_db["MAP"]
1458 map[val * length:(val * length) + length] = mapline.encode()
1459 if not world_db["MAP"]:
1460 world_db["MAP"] = map
1463 def ThingMap_helper(str_int, mapline):
1464 val = valid_map_line(str_int, mapline)
1466 length = world_db["MAP_LENGTH"]
1467 if not world_db["Things"][command_tid.id][maptype]:
1468 map = bytearray(b' ' * (length ** 2))
1470 map = world_db["Things"][command_tid.id][maptype]
1471 map[val * length:(val * length) + length] = mapline.encode()
1472 if not world_db["Things"][command_tid.id][maptype]:
1473 world_db["Things"][command_tid.id][maptype] = map
1475 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1479 def setter_tpos(axis):
1480 """Generate setter for T_POSX or T_POSY of selected Thing.
1482 If world is active, rebuilds animate things' fovmap, player's memory map.
1485 def helper(str_int):
1486 val = integer_test(str_int, 0, 255)
1488 if val < world_db["MAP_LENGTH"]:
1489 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1490 if world_db["WORLD_ACTIVE"] \
1491 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1492 build_fov_map(world_db["Things"][command_tid.id])
1493 if 0 == command_tid.id:
1494 update_map_memory(world_db["Things"][command_tid.id])
1496 print("Ignoring: Position is outside of map.")
1500 def command_ttid(id_string):
1501 """Set ID of ThingType to manipulate. ID unused? Create new one.
1503 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1506 id = id_setter(id_string, "ThingTypes", command_ttid)
1508 world_db["ThingTypes"][id] = {
1509 "TT_NAME": "(none)",
1512 "TT_PROLIFERATE": 0,
1513 "TT_START_NUMBER": 0,
1520 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1524 def command_ttname(name):
1525 """Set TT_NAME of selected ThingType."""
1526 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1530 def command_tttool(name):
1531 """Set TT_TOOL of selected ThingType."""
1532 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1536 def command_ttsymbol(char):
1537 """Set TT_SYMBOL of selected ThingType. """
1539 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1541 print("Ignoring: Argument must be single character.")
1545 def command_ttcorpseid(str_int):
1546 """Set TT_CORPSE_ID of selected ThingType."""
1547 val = integer_test(str_int, 0)
1549 if val in world_db["ThingTypes"]:
1550 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1552 print("Ignoring: Corpse ID belongs to no known ThignType.")
1555 def command_taid(id_string):
1556 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1558 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1560 id = id_setter(id_string, "ThingActions", command_taid, True)
1562 world_db["ThingActions"][id] = {
1568 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1571 @test_ThingAction_id
1572 def command_taname(name):
1573 """Set TA_NAME of selected ThingAction.
1575 The name must match a valid thing action function. If after the name
1576 setting no ThingAction with name "wait" remains, call set_world_inactive().
1578 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1579 or name == "pick_up":
1580 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1581 if 1 == world_db["WORLD_ACTIVE"]:
1582 wait_defined = False
1583 for id in world_db["ThingActions"]:
1584 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1587 if not wait_defined:
1588 set_world_inactive()
1590 print("Ignoring: Invalid action name.")
1591 # In contrast to the original,naming won't map a function to a ThingAction.
1595 """Call ai() on player Thing, then turn_over()."""
1596 ai(world_db["Things"][0])
1600 """Commands database.
1602 Map command start tokens to ([0]) number of expected command arguments, ([1])
1603 the command's meta-ness (i.e. is it to be written to the record file, is it to
1604 be ignored in replay mode if read from server input file), and ([2]) a function
1608 "QUIT": (0, True, command_quit),
1609 "PING": (0, True, command_ping),
1610 "THINGS_HERE": (2, True, command_thingshere),
1611 "MAKE_WORLD": (1, False, command_makeworld),
1612 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1613 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1614 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1615 "MAP_LENGTH": (1, False, command_maplength),
1616 "WORLD_ACTIVE": (1, False, command_worldactive),
1617 "MAP": (2, False, setter_map("MAP")),
1618 "TA_ID": (1, False, command_taid),
1619 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1620 "TA_NAME": (1, False, command_taname),
1621 "TT_ID": (1, False, command_ttid),
1622 "TT_NAME": (1, False, command_ttname),
1623 "TT_TOOL": (1, False, command_tttool),
1624 "TT_SYMBOL": (1, False, command_ttsymbol),
1625 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1626 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1627 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1629 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1631 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1632 "T_ID": (1, False, command_tid),
1633 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1634 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1635 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1636 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1637 "T_COMMAND": (1, False, command_tcommand),
1638 "T_TYPE": (1, False, command_ttype),
1639 "T_CARRIES": (1, False, command_tcarries),
1640 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1641 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1642 "T_MEMTHING": (3, False, command_tmemthing),
1643 "T_POSY": (1, False, setter_tpos("Y")),
1644 "T_POSX": (1, False, setter_tpos("X")),
1645 "wait": (0, False, play_commander("wait")),
1646 "move": (1, False, play_commander("move")),
1647 "pick_up": (0, False, play_commander("pick_up")),
1648 "drop": (1, False, play_commander("drop", True)),
1649 "use": (1, False, play_commander("use", True)),
1650 "ai": (0, False, command_ai)
1652 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1655 """World state database. With sane default values. (Randomness is in rand.)"""
1667 """Mapping of direction names to internal direction chars."""
1668 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1669 "west": "s", "north-west": "w", "north-east": "e"}
1671 """File IO database."""
1673 "path_save": "save",
1674 "path_record": "record_save",
1675 "path_worldconf": "confserver/world",
1676 "path_server": "server/",
1677 "path_in": "server/in",
1678 "path_out": "server/out",
1679 "path_worldstate": "server/worldstate",
1680 "tmp_suffix": "_tmp",
1681 "kicked_by_rival": False,
1682 "worldstate_updateable": False
1687 libpr = prep_library()
1688 rand = RandomnessIO()
1689 opts = parse_command_line_arguments()
1691 io_db["path_save"] = opts.savefile
1692 io_db["path_record"] = "record_" + opts.savefile
1695 io_db["verbose"] = True
1696 if None != opts.replay:
1700 except SystemExit as exit:
1701 print("ABORTING: " + exit.args[0])
1703 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")