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.
18 """"Interface to libplomrogue's pseudo-randomness generator."""
20 def set_seed(self, seed):
21 libpr.seed_rrand(1, seed)
24 return libpr.seed_rrand(0, 0)
29 seed = property(get_seed, set_seed)
33 """Prepare ctypes library at ./libplomrogue.so"""
34 libpath = ("./libplomrogue.so")
35 if not os.access(libpath, os.F_OK):
36 raise SystemExit("No library " + libpath + ", run ./redo first?")
37 libpr = ctypes.cdll.LoadLibrary(libpath)
38 libpr.seed_rrand.restype = ctypes.c_uint32
42 def c_pointer_to_bytearray(ba):
43 """Return C char * pointer to ba."""
44 type = ctypes.c_char * len(ba)
45 return type.from_buffer(ba)
48 def strong_write(file, string):
49 """Apply write(string), then flush()."""
54 def setup_server_io():
55 """Fill IO files DB with proper file( path)s. Write process IO test string.
57 Ensure IO files directory at server/. Remove any old input file if found.
58 Set up new input file for reading, and new output file for writing. Start
59 output file with process hash line of format PID + " " + floated UNIX time
60 (io_db["teststring"]). Raise SystemExit if file is found at path of either
61 record or save file plus io_db["tmp_suffix"].
63 def detect_atomic_leftover(path, tmp_suffix):
64 path_tmp = path + tmp_suffix
65 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
66 "aborted previous attempt to write '" + path + "'. Aborting " \
67 "until matter is resolved by removing it from its current path."
68 if os.access(path_tmp, os.F_OK):
70 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
71 io_db["save_wait"] = 0
72 io_db["verbose"] = False
73 io_db["record_chunk"] = ""
74 os.makedirs(io_db["path_server"], exist_ok=True)
75 io_db["file_out"] = open(io_db["path_out"], "w")
76 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
77 if os.access(io_db["path_in"], os.F_OK):
78 os.remove(io_db["path_in"])
79 io_db["file_in"] = open(io_db["path_in"], "w")
80 io_db["file_in"].close()
81 io_db["file_in"] = open(io_db["path_in"], "r")
82 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
83 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
86 def cleanup_server_io():
87 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
88 def helper(file_key, path_key):
90 io_db[file_key].close()
91 if not io_db["kicked_by_rival"] \
92 and os.access(io_db[path_key], os.F_OK):
93 os.remove(io_db[path_key])
94 helper("file_in", "path_in")
95 helper("file_out", "path_out")
96 helper("file_worldstate", "path_worldstate")
97 if "file_record" in io_db:
98 io_db["file_record"].close()
101 def obey(command, prefix, replay=False, do_record=False):
102 """Call function from commands_db mapped to command's first token.
104 Tokenize command string with shlex.split(comments=True). If replay is set,
105 a non-meta command from the commands_db merely triggers obey() on the next
106 command from the records file. If not, non-meta commands set
107 io_db["worldstate_updateable"] to world_db["WORLD_ACTIVE"], and, if
108 do_record is set, are recorded to io_db["record_chunk"], and save_world()
109 is called (and io_db["record_chunk"] written) if 15 seconds have passed
110 since the last time it was called. The prefix string is inserted into the
111 server's input message between its beginning 'input ' and ':'. All activity
112 is preceded by a server_test() call. Commands that start with a lowercase
113 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
117 print("input " + prefix + ": " + command)
119 tokens = shlex.split(command, comments=True)
120 except ValueError as err:
121 print("Can't tokenize command string: " + str(err) + ".")
123 if len(tokens) > 0 and tokens[0] in commands_db \
124 and len(tokens) == commands_db[tokens[0]][0] + 1:
125 if commands_db[tokens[0]][1]:
126 commands_db[tokens[0]][2](*tokens[1:])
127 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
128 print("Ignoring lowercase-starting commands when world inactive.")
130 print("Due to replay mode, reading command as 'go on in record'.")
131 line = io_db["file_record"].readline()
133 obey(line.rstrip(), io_db["file_record"].prefix
134 + str(io_db["file_record"].line_n))
135 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
137 print("Reached end of record file.")
139 commands_db[tokens[0]][2](*tokens[1:])
141 io_db["record_chunk"] += command + "\n"
142 if time.time() > io_db["save_wait"] + 15:
143 atomic_write(io_db["path_record"], io_db["record_chunk"],
145 if world_db["WORLD_ACTIVE"]:
147 io_db["record_chunk"] = ""
148 io_db["save_wait"] = time.time()
149 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
150 elif 0 != len(tokens):
151 print("Invalid command/argument, or bad number of tokens.")
154 def atomic_write(path, text, do_append=False, delete=True):
155 """Atomic write of text to file at path, appended if do_append is set."""
156 path_tmp = path + io_db["tmp_suffix"]
160 if os.access(path, os.F_OK):
161 shutil.copyfile(path, path_tmp)
162 file = open(path_tmp, mode)
163 strong_write(file, text)
165 if delete and os.access(path, os.F_OK):
167 os.rename(path_tmp, path)
171 """Save all commands needed to reconstruct current world state."""
174 string = string.replace("\u005C", '\u005C\u005C')
175 return '"' + string.replace('"', '\u005C"') + '"'
180 if key == "MAP" or world_db["Things"][id][key]:
181 map = world_db["MAP"] if key == "MAP" \
182 else world_db["Things"][id][key]
183 length = world_db["MAP_LENGTH"]
184 for i in range(length):
185 line = map[i * length:(i * length) + length].decode()
186 string = string + key + " " + str(i) + " " + quote(line) \
193 for memthing in world_db["Things"][id]["T_MEMTHING"]:
194 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
195 str(memthing[1]) + " " + str(memthing[2]) + "\n"
198 def helper(category, id_string, special_keys={}):
200 for id in sorted(world_db[category].keys()):
201 string = string + id_string + " " + str(id) + "\n"
202 for key in sorted(world_db[category][id].keys()):
203 if not key in special_keys:
204 x = world_db[category][id][key]
205 argument = quote(x) if str == type(x) else str(x)
206 string = string + key + " " + argument + "\n"
207 elif special_keys[key]:
208 string = string + special_keys[key](id)
212 for key in sorted(world_db.keys()):
213 if (not isinstance(world_db[key], dict)) and key != "MAP" and \
214 key != "WORLD_ACTIVE":
215 string = string + key + " " + str(world_db[key]) + "\n"
216 string = string + mapsetter("MAP")()
217 string = string + helper("ThingActions", "TA_ID")
218 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
219 for id in sorted(world_db["ThingTypes"].keys()):
220 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
221 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
222 string = string + helper("Things", "T_ID",
223 {"T_CARRIES": False, "carried": False,
224 "T_MEMMAP": mapsetter("T_MEMMAP"),
225 "T_MEMTHING": memthing, "fovmap": False,
226 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
227 for id in sorted(world_db["Things"].keys()):
228 if [] != world_db["Things"][id]["T_CARRIES"]:
229 string = string + "T_ID " + str(id) + "\n"
230 for carried in sorted(world_db["Things"][id]["T_CARRIES"]):
231 string = string + "T_CARRIES " + str(carried) + "\n"
232 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
233 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
234 atomic_write(io_db["path_save"], string)
237 def obey_lines_in_file(path, name, do_record=False):
238 """Call obey() on each line of path's file, use name in input prefix."""
239 file = open(path, "r")
241 for line in file.readlines():
242 obey(line.rstrip(), name + "file line " + str(line_n),
248 def parse_command_line_arguments():
249 """Return settings values read from command line arguments."""
250 parser = argparse.ArgumentParser()
251 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
253 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
255 parser.add_argument('-v', dest='verbose', action='store_true')
256 opts, unknown = parser.parse_known_args()
261 """Ensure valid server out file belonging to current process.
263 This is done by comparing io_db["teststring"] to what's found at the start
264 of the current file at io_db["path_out"]. On failure, set
265 io_db["kicked_by_rival"] and raise SystemExit.
267 if not os.access(io_db["path_out"], os.F_OK):
268 raise SystemExit("Server output file has disappeared.")
269 file = open(io_db["path_out"], "r")
270 test = file.readline().rstrip("\n")
272 if test != io_db["teststring"]:
273 io_db["kicked_by_rival"] = True
274 msg = "Server test string in server output file does not match. This" \
275 " indicates that the current server process has been " \
276 "superseded by another one."
277 raise SystemExit(msg)
281 """Return next newline-delimited command from server in file.
283 Keep building return string until a newline is encountered. Pause between
284 unsuccessful reads, and after too much waiting, run server_test().
286 wait_on_fail = 0.03333
291 add = io_db["file_in"].readline()
293 command = command + add
294 if len(command) > 0 and "\n" == command[-1]:
295 command = command[:-1]
298 time.sleep(wait_on_fail)
299 if now + max_wait < time.time():
305 def try_worldstate_update():
306 """Write worldstate file if io_db["worldstate_updateable"] is set."""
307 if io_db["worldstate_updateable"]:
309 def write_map(string, map):
310 for i in range(length):
311 line = map[i * length:(i * length) + length].decode()
312 string = string + line + "\n"
316 if [] == world_db["Things"][0]["T_CARRIES"]:
317 inventory = "(none)\n"
319 for id in world_db["Things"][0]["T_CARRIES"]:
320 type_id = world_db["Things"][id]["T_TYPE"]
321 name = world_db["ThingTypes"][type_id]["TT_NAME"]
322 inventory = inventory + name + "\n"
323 string = str(world_db["TURN"]) + "\n" + \
324 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
325 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
326 inventory + "%\n" + \
327 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
328 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
329 str(world_db["MAP_LENGTH"]) + "\n"
330 length = world_db["MAP_LENGTH"]
331 fov = bytearray(b' ' * (length ** 2))
333 for pos in [pos for pos in range(length ** 2)
334 if ord_v == world_db["Things"][0]["fovmap"][pos]]:
335 fov[pos] = world_db["MAP"][pos]
336 length = world_db["MAP_LENGTH"]
337 for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
338 for id in world_db["Things"]
339 if not world_db["Things"][id]["carried"]
340 if world_db["Things"][id]["T_TYPE"] == tid
341 if world_db["Things"][0]["fovmap"][
342 world_db["Things"][id]["T_POSY"] * length
343 + world_db["Things"][id]["T_POSX"]] == ord_v]:
344 type = world_db["Things"][id]["T_TYPE"]
345 c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
346 fov[world_db["Things"][id]["T_POSY"] * length
347 + world_db["Things"][id]["T_POSX"]] = c
348 string = write_map(string, fov)
349 mem = world_db["Things"][0]["T_MEMMAP"][:]
350 for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
351 for mt in world_db["Things"][0]["T_MEMTHING"]
353 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
354 mem[(mt[1] * length) + mt[2]] = ord(c)
355 string = write_map(string, mem)
356 atomic_write(io_db["path_worldstate"], string, delete=False)
357 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
358 io_db["worldstate_updateable"] = False
362 """Replay game from record file.
364 Use opts.replay as breakpoint turn to which to replay automatically before
365 switching to manual input by non-meta commands in server input file
366 triggering further reads of record file. Ensure opts.replay is at least 1.
367 Run try_worldstate_update() before each interactive obey()/read_command().
371 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
372 " (if so late a turn is to be found).")
373 if not os.access(io_db["path_record"], os.F_OK):
374 raise SystemExit("No record file found to replay.")
375 io_db["file_record"] = open(io_db["path_record"], "r")
376 io_db["file_record"].prefix = "record file line "
377 io_db["file_record"].line_n = 1
378 while world_db["TURN"] < opts.replay:
379 line = io_db["file_record"].readline()
382 obey(line.rstrip(), io_db["file_record"].prefix
383 + str(io_db["file_record"].line_n))
384 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
386 try_worldstate_update()
387 obey(read_command(), "in file", replay=True)
391 """Play game by server input file commands. Before, load save file found.
393 If no save file is found, a new world is generated from the commands in the
394 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
395 command and all that follow via the server input file. Run
396 try_worldstate_update() before each interactive obey()/read_command().
398 if os.access(io_db["path_save"], os.F_OK):
399 obey_lines_in_file(io_db["path_save"], "save")
401 if not os.access(io_db["path_worldconf"], os.F_OK):
402 msg = "No world config file from which to start a new world."
403 raise SystemExit(msg)
404 obey_lines_in_file(io_db["path_worldconf"], "world config ",
406 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
408 try_worldstate_update()
409 obey(read_command(), "in file", do_record=True)
413 """(Re-)make island map.
415 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
416 start with one land cell in the middle, then go into cycle of repeatedly
417 selecting a random sea cell and transforming it into land if it is neighbor
418 to land. The cycle ends when a land cell is due to be created at the map's
419 border. Then put some trees on the map (TODO: more precise algorithm desc).
422 def is_neighbor(coordinates, type):
425 length = world_db["MAP_LENGTH"]
427 diag_west = x + (ind > 0)
428 diag_east = x + (ind < (length - 1))
429 pos = (y * length) + x
430 if (y > 0 and diag_east
431 and type == chr(world_db["MAP"][pos - length + ind])) \
433 and type == chr(world_db["MAP"][pos + 1])) \
434 or (y < (length - 1) and diag_east
435 and type == chr(world_db["MAP"][pos + length + ind])) \
436 or (y > 0 and diag_west
437 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
439 and type == chr(world_db["MAP"][pos - 1])) \
440 or (y < (length - 1) and diag_west
441 and type == chr(world_db["MAP"][pos + length - (not ind)])):
445 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
446 length = world_db["MAP_LENGTH"]
447 add_half_width = (not (length % 2)) * int(length / 2)
448 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
450 y = rand.next() % length
451 x = rand.next() % length
452 pos = (y * length) + x
453 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
454 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
456 world_db["MAP"][pos] = ord(".")
457 n_trees = int((length ** 2) / 16)
459 while (i_trees <= n_trees):
460 single_allowed = rand.next() % 32
461 y = rand.next() % length
462 x = rand.next() % length
463 pos = (y * length) + x
464 if "." == chr(world_db["MAP"][pos]) \
465 and ((not single_allowed) or is_neighbor((y, x), "X")):
466 world_db["MAP"][pos] = ord("X")
468 # This all-too-precise replica of the original C code misses iter_limit().
471 def update_map_memory(t, age_map=True):
472 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
474 def age_some_memdepthmap_on_nonfov_cells():
475 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
479 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
480 # if not ord_v == t["fovmap"][pos]
481 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
482 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
483 # if not rand.next() % (2 **
484 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
485 # t["T_MEMDEPTHMAP"][pos] += 1
486 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
487 fovmap = c_pointer_to_bytearray(t["fovmap"])
488 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
490 if not t["T_MEMMAP"]:
491 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
492 if not t["T_MEMDEPTHMAP"]:
493 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
496 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
497 if ord_v == t["fovmap"][pos]]:
498 t["T_MEMDEPTHMAP"][pos] = ord_0
499 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
501 age_some_memdepthmap_on_nonfov_cells()
502 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
503 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
505 for id in [id for id in world_db["Things"]
506 if not world_db["Things"][id]["carried"]]:
507 type = world_db["Things"][id]["T_TYPE"]
508 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
509 y = world_db["Things"][id]["T_POSY"]
510 x = world_db["Things"][id]["T_POSX"]
511 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
512 t["T_MEMTHING"].append((type, y, x))
515 def set_world_inactive():
516 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
518 if os.access(io_db["path_worldstate"], os.F_OK):
519 os.remove(io_db["path_worldstate"])
520 world_db["WORLD_ACTIVE"] = 0
523 def integer_test(val_string, min, max=None):
524 """Return val_string if integer >= min & (if max set) <= max, else None."""
526 val = int(val_string)
527 if val < min or (max is not None and val > max):
531 msg = "Ignoring: Please use integer >= " + str(min)
533 msg += " and <= " + str(max)
539 def setter(category, key, min, max=None):
540 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
543 val = integer_test(val_string, min, max)
547 if category == "Thing":
548 id_store = command_tid
549 decorator = test_Thing_id
550 elif category == "ThingType":
551 id_store = command_ttid
552 decorator = test_ThingType_id
553 elif category == "ThingAction":
554 id_store = command_taid
555 decorator = test_ThingAction_id
559 val = integer_test(val_string, min, max)
561 world_db[category + "s"][id_store.id][key] = val
565 def build_fov_map(t):
566 """Build Thing's FOV map."""
567 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
568 fovmap = c_pointer_to_bytearray(t["fovmap"])
569 map = c_pointer_to_bytearray(world_db["MAP"])
570 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
571 raise RuntimeError("Malloc error in build_fov_Map().")
575 """Send quick usage info to log."""
576 strong_write(io_db["file_out"], "LOG See README file for help.\n")
579 def decrement_lifepoints(t):
580 """Decrement t's lifepoints by 1, and if to zero, corpse it.
582 If t is the player avatar, only blank its fovmap, so that the client may
583 still display memory data. On non-player things, erase fovmap and memory.
584 Dying actors drop all their things.
586 t["T_LIFEPOINTS"] -= 1
587 if 0 == t["T_LIFEPOINTS"]:
588 for id in t["T_CARRIES"]:
589 t["T_CARRIES"].remove(id)
590 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
591 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
592 world_db["Things"][id]["carried"] = False
593 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
594 if world_db["Things"][0] == t:
595 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
596 strong_write(io_db["file_out"], "LOG You die.\n")
597 strong_write(io_db["file_out"],
598 "LOG See README on how to start over.\n")
601 t["T_MEMMAP"] = False
602 t["T_MEMDEPTHMAP"] = False
606 def mv_yx_in_dir_legal(dir, y, x):
607 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
608 dir_c = dir.encode("ascii")[0]
609 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
611 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
612 return (test, libpr.result_y(), libpr.result_x())
616 """Make t do nothing (but loudly, if player avatar)."""
617 if t == world_db["Things"][0]:
618 strong_write(io_db["file_out"], "LOG You wait.\n")
622 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
624 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
625 t["T_POSY"], t["T_POSX"])
626 if 1 == move_result[0]:
627 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
628 hitted = [id for id in world_db["Things"]
629 if world_db["Things"][id] != t
630 if world_db["Things"][id]["T_LIFEPOINTS"]
631 if world_db["Things"][id]["T_POSY"] == move_result[1]
632 if world_db["Things"][id]["T_POSX"] == move_result[2]]
635 if t == world_db["Things"][0]:
636 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
637 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
638 strong_write(io_db["file_out"], "LOG You wound "
639 + hitted_name + ".\n")
641 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
642 strong_write(io_db["file_out"], "LOG " + hitter_name +
644 decrement_lifepoints(world_db["Things"][hit_id])
646 passable = "." == chr(world_db["MAP"][pos])
647 dir = [dir for dir in directions_db
648 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
650 t["T_POSY"] = move_result[1]
651 t["T_POSX"] = move_result[2]
652 for id in t["T_CARRIES"]:
653 world_db["Things"][id]["T_POSY"] = move_result[1]
654 world_db["Things"][id]["T_POSX"] = move_result[2]
656 if t == world_db["Things"][0]:
657 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
658 elif t == world_db["Things"][0]:
659 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
662 def actor_pick_up(t):
663 """Make t pick up (topmost?) Thing from ground into inventory.
665 Define topmostness by how low the thing's type ID is.
667 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
668 if not world_db["Things"][id]["carried"]
669 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
670 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
674 tid = world_db["Things"][iid]["T_TYPE"]
675 if lowest_tid == -1 or tid < lowest_tid:
678 world_db["Things"][id]["carried"] = True
679 t["T_CARRIES"].append(id)
680 if t == world_db["Things"][0]:
681 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
682 elif t == world_db["Things"][0]:
683 err = "You try to pick up an object, but there is none."
684 strong_write(io_db["file_out"], "LOG " + err + "\n")
688 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
689 # TODO: Handle case where T_ARGUMENT matches nothing.
690 if len(t["T_CARRIES"]):
691 id = t["T_CARRIES"][t["T_ARGUMENT"]]
692 t["T_CARRIES"].remove(id)
693 world_db["Things"][id]["carried"] = False
694 if t == world_db["Things"][0]:
695 strong_write(io_db["file_out"], "LOG You drop an object.\n")
696 elif t == world_db["Things"][0]:
697 err = "You try to drop an object, but you own none."
698 strong_write(io_db["file_out"], "LOG " + err + "\n")
702 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
703 # TODO: Handle case where T_ARGUMENT matches nothing.
704 if len(t["T_CARRIES"]):
705 id = t["T_CARRIES"][t["T_ARGUMENT"]]
706 type = world_db["Things"][id]["T_TYPE"]
707 if world_db["ThingTypes"][type]["TT_TOOL"] == "food":
708 t["T_CARRIES"].remove(id)
709 del world_db["Things"][id]
710 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
711 if t == world_db["Things"][0]:
712 strong_write(io_db["file_out"],
713 "LOG You consume this object.\n")
714 elif t == world_db["Things"][0]:
715 strong_write(io_db["file_out"],
716 "LOG You try to use this object, but fail.\n")
717 elif t == world_db["Things"][0]:
718 strong_write(io_db["file_out"],
719 "LOG You try to use an object, but you own none.\n")
722 def thingproliferation(t, prol_map):
723 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
725 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
726 marked '.' in prol_map. If there are several map cell candidates, one is
729 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
730 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
732 for dir in [directions_db[key] for key in sorted(directions_db.keys())]:
733 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
734 if mv_result[0] and ord('.') == prol_map[mv_result[1]
735 * world_db["MAP_LENGTH"]
737 candidates.append((mv_result[1], mv_result[2]))
739 i = rand.next() % len(candidates)
740 id = id_setter(-1, "Things")
741 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
742 world_db["Things"][id] = newT
746 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
748 On success, decrease satiation score by 32.
750 if t["T_SATIATION"] > 0 \
751 and t["T_LIFEPOINTS"] < \
752 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
753 and 0 == (rand.next() % 31) \
754 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
755 if world_db["ThingActions"][id]["TA_NAME"] ==
757 t["T_LIFEPOINTS"] += 1
758 t["T_SATIATION"] -= 32
759 if t == world_db["Things"][0]:
760 strong_write(io_db["file_out"], "LOG You heal.\n")
764 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
765 if t["T_SATIATION"] > -32768:
766 t["T_SATIATION"] -= 1
767 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
768 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
769 raise RuntimeError("A thing that should not hunger is hungering.")
770 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
771 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
772 if t == world_db["Things"][0]:
773 if t["T_SATIATION"] < 0:
774 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
776 strong_write(io_db["file_out"],
777 "LOG You suffer from over-eating.\n")
778 decrement_lifepoints(t)
781 def get_dir_to_target(t, filter):
782 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
784 The path-wise nearest target is chosen, via the shortest available path.
785 Target must not be t. On succcess, return positive value, else False.
787 "a": Thing in FOV is below a certain distance, animate, but of ThingType
788 that is not t's, and starts out weaker than t is; build path as
789 avoiding things of t's ThingType
790 "f": neighbor cell (not inhabited by any animate Thing) further away from
791 animate Thing not further than x steps away and in FOV and of a
792 ThingType that is not t's, and starts out stronger or as strong as t
793 is currently; or (cornered), if no such flight cell, but Thing of
794 above criteria is too near,1 a cell closer to it, or, if less near,
796 "c": Thing in memorized map is consumable
797 "s": memory map cell with greatest-reachable degree of unexploredness
800 def zero_score_map_where_char_on_memdepthmap(c):
801 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
802 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
803 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
804 # set_map_score(i, 0)
805 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
806 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
807 raise RuntimeError("No score map allocated for "
808 "zero_score_map_where_char_on_memdepthmap().")
810 def set_map_score(pos, score):
811 test = libpr.set_map_score(pos, score)
813 raise RuntimeError("No score map allocated for set_map_score().")
815 def get_map_score(pos):
816 result = libpr.get_map_score(pos)
818 raise RuntimeError("No score map allocated for get_map_score().")
822 if t["fovmap"] and ("a" == filter or "f" == filter):
823 for id in world_db["Things"]:
824 Thing = world_db["Things"][id]
825 if Thing != t and Thing["T_LIFEPOINTS"] and \
826 t["T_TYPE"] != Thing["T_TYPE"] and \
827 'v' == chr(t["fovmap"][(Thing["T_POSY"]
828 * world_db["MAP_LENGTH"])
830 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
831 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
833 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
836 elif t["T_MEMMAP"] and "c" == filter:
837 for mt in t["T_MEMTHING"]:
838 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
840 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
844 def set_cells_passable_on_memmap_to_65534_on_scoremap():
845 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
847 # memmap = t["T_MEMMAP"]
848 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
849 # if ord_dot == memmap[i]]:
850 # set_map_score(i, 65534) # i.e. 65535-1
851 map = c_pointer_to_bytearray(t["T_MEMMAP"])
852 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
853 raise RuntimeError("No score map allocated for set_cells_passable"
854 "_on_memmap_to_65534_on_scoremap().")
856 def init_score_map():
857 test = libpr.init_score_map()
859 raise RuntimeError("Malloc error in init_score_map().")
862 set_cells_passable_on_memmap_to_65534_on_scoremap()
864 for id in world_db["Things"]:
865 Thing = world_db["Things"][id]
866 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
868 if t != Thing and Thing["T_LIFEPOINTS"] and \
869 t["T_TYPE"] != Thing["T_TYPE"] and \
870 ord_v == t["fovmap"][pos] and \
871 t["T_LIFEPOINTS"] > \
872 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
873 set_map_score(pos, 0)
874 elif t["T_TYPE"] == Thing["T_TYPE"]:
875 set_map_score(pos, 65535)
877 for id in [id for id in world_db["Things"]
878 if world_db["Things"][id]["T_LIFEPOINTS"]]:
879 Thing = world_db["Things"][id]
880 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
882 if t["T_TYPE"] != Thing["T_TYPE"] and \
883 ord_v == t["fovmap"][pos] and \
884 t["T_LIFEPOINTS"] <= \
885 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
886 set_map_score(pos, 0)
888 for mt in [mt for mt in t["T_MEMTHING"]
889 if ord_blank != t["T_MEMMAP"][mt[1]
890 * world_db["MAP_LENGTH"]
892 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
893 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
895 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
897 def rand_target_dir(neighbors, cmp, dirs):
900 for i in range(len(dirs)):
901 if cmp == neighbors[i]:
902 candidates.append(dirs[i])
904 return candidates[rand.next() % n_candidates] if n_candidates else 0
906 def get_neighbor_scores(dirs, eye_pos):
908 if libpr.ready_neighbor_scores(eye_pos):
909 raise RuntimeError("No score map allocated for " +
910 "ready_neighbor_scores.()")
911 for i in range(len(dirs)):
912 scores.append(libpr.get_neighbor_score(i))
915 def get_dir_from_neighbors():
916 dir_to_target = False
918 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
919 neighbors = get_neighbor_scores(dirs, eye_pos)
921 inhabited = [world_db["Things"][id]["T_POSY"]
922 * world_db["MAP_LENGTH"]
923 + world_db["Things"][id]["T_POSX"]
924 for id in world_db["Things"]
925 if world_db["Things"][id]["T_LIFEPOINTS"]]
926 for i in range(len(dirs)):
927 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
928 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
930 for pos in [pos for pos in inhabited if pos == pos_cmp]:
933 minmax_start = 0 if "f" == filter else 65535 - 1
934 minmax_neighbor = minmax_start
935 for i in range(len(dirs)):
936 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
937 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
938 or ("f" != filter and minmax_neighbor > neighbors[i]):
939 minmax_neighbor = neighbors[i]
940 if minmax_neighbor != minmax_start:
941 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
943 if not dir_to_target:
944 if 1 == get_map_score(eye_pos):
945 dir_to_target = rand_target_dir(neighbors, 0, dirs)
946 elif 3 >= get_map_score(eye_pos):
947 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
949 world_db["ThingActions"][id]["TA_NAME"]
952 elif dir_to_target and 3 < get_map_score(eye_pos):
954 elif "a" == filter and 10 <= get_map_score(eye_pos):
958 dir_to_target = False
960 run_i = 9 + 1 if "s" == filter else 1
961 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
964 mem_depth_c = b'9' if b' ' == mem_depth_c \
965 else bytes([mem_depth_c[0] - 1])
966 if libpr.dijkstra_map():
967 raise RuntimeError("No score map allocated for dijkstra_map().")
968 dir_to_target = get_dir_from_neighbors()
969 libpr.free_score_map()
970 if dir_to_target and str == type(dir_to_target):
971 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
972 if world_db["ThingActions"][id]["TA_NAME"]
974 t["T_ARGUMENT"] = ord(dir_to_target)
978 def standing_on_food(t):
979 """Return True/False whether t is standing on a consumable."""
980 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
981 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
982 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
983 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
984 ["TT_TOOL"] == "food"]:
989 def get_inventory_slot_to_consume(t):
990 """Return slot Id of strongest consumable in t's inventory, else -1."""
994 for id in t["T_CARRIES"]:
995 type = world_db["Things"][id]["T_TYPE"]
996 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
997 and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > cmp_food:
998 cmp_food = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1005 """Determine next command/argment for actor t via AI algorithms.
1007 AI will look for, and move towards, enemies (animate Things not of their
1008 own ThingType); if they see none, they will consume consumables in their
1009 inventory; if there are none, they will pick up what they stand on if they
1010 stand on consumables; if they stand on none, they will move towards the
1011 next consumable they see or remember on the map; if they see or remember
1012 none, they will explore parts of the map unseen since ever or for at least
1013 one turn; if there is nothing to explore, they will simply wait.
1015 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1016 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1017 if not get_dir_to_target(t, "f"):
1018 sel = get_inventory_slot_to_consume(t)
1020 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1021 if world_db["ThingActions"][id]["TA_NAME"]
1023 t["T_ARGUMENT"] = sel
1024 elif standing_on_food(t):
1025 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1026 if world_db["ThingActions"][id]["TA_NAME"]
1028 elif (not get_dir_to_target(t, "c")) and \
1029 (not get_dir_to_target(t, "a")):
1030 get_dir_to_target(t, "s")
1034 """Run game world and its inhabitants until new player input expected."""
1036 whilebreaker = False
1037 while world_db["Things"][0]["T_LIFEPOINTS"]:
1038 proliferable_map = world_db["MAP"][:]
1039 for id in [id for id in world_db["Things"]
1040 if not world_db["Things"][id]["carried"]]:
1041 y = world_db["Things"][id]["T_POSY"]
1042 x = world_db["Things"][id]["T_POSX"]
1043 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1044 for id in [id for id in world_db["Things"]]: # Only what's from start!
1045 if not id in world_db["Things"] or \
1046 world_db["Things"][id]["carried"]: # May have been consumed or
1047 continue # picked up during turn …
1048 Thing = world_db["Things"][id]
1049 if Thing["T_LIFEPOINTS"]:
1050 if not Thing["T_COMMAND"]:
1051 update_map_memory(Thing)
1058 if Thing["T_LIFEPOINTS"]:
1059 Thing["T_PROGRESS"] += 1
1060 taid = [a for a in world_db["ThingActions"]
1061 if a == Thing["T_COMMAND"]][0]
1062 ThingAction = world_db["ThingActions"][taid]
1063 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1064 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1065 Thing["T_COMMAND"] = 0
1066 Thing["T_PROGRESS"] = 0
1067 thingproliferation(Thing, proliferable_map)
1070 world_db["TURN"] += 1
1073 def new_Thing(type, pos=(0, 0)):
1074 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1076 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1088 "T_MEMDEPTHMAP": False,
1091 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1092 build_fov_map(thing)
1096 def id_setter(id, category, id_store=False, start_at_1=False):
1097 """Set ID of object of category to manipulate ID unused? Create new one.
1098 The ID is stored as id_store.id (if id_store is set). If the integer of the
1099 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1100 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1101 always returned when no new object is created, else the new object's ID.
1103 min = 0 if start_at_1 else -1
1105 id = integer_test(id, min)
1107 if id in world_db[category]:
1112 if (start_at_1 and 0 == id) \
1113 or ((not start_at_1) and (id < 0)):
1114 id = 0 if start_at_1 else -1
1117 if id not in world_db[category]:
1125 """Send PONG line to server output file."""
1126 strong_write(io_db["file_out"], "PONG\n")
1130 """Abort server process."""
1131 if None == opts.replay:
1132 if world_db["WORLD_ACTIVE"]:
1134 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1135 raise SystemExit("received QUIT command")
1138 def command_thingshere(str_y, str_x):
1139 """Write to out file list of Things known to player at coordinate y, x."""
1140 if world_db["WORLD_ACTIVE"]:
1141 y = integer_test(str_y, 0, 255)
1142 x = integer_test(str_x, 0, 255)
1143 length = world_db["MAP_LENGTH"]
1144 if None != y and None != x and y < length and x < length:
1145 pos = (y * world_db["MAP_LENGTH"]) + x
1146 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1147 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1148 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1149 for id in world_db["Things"]
1150 if not world_db["Things"][id]["carried"]
1151 if world_db["Things"][id]["T_TYPE"] == tid
1152 if y == world_db["Things"][id]["T_POSY"]
1153 if x == world_db["Things"][id]["T_POSX"]]:
1154 type = world_db["Things"][id]["T_TYPE"]
1155 name = world_db["ThingTypes"][type]["TT_NAME"]
1156 strong_write(io_db["file_out"], name + "\n")
1158 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1159 for mt in world_db["Things"][0]["T_MEMTHING"]
1160 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1161 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1162 strong_write(io_db["file_out"], name + "\n")
1163 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1165 print("Ignoring: Invalid map coordinates.")
1167 print("Ignoring: Command only works on existing worlds.")
1170 def play_commander(action, args=False):
1171 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1173 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1177 id = [x for x in world_db["ThingActions"]
1178 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1179 world_db["Things"][0]["T_COMMAND"] = id
1182 def set_command_and_argument_int(str_arg):
1183 val = integer_test(str_arg, 0, 255)
1185 world_db["Things"][0]["T_ARGUMENT"] = val
1188 def set_command_and_argument_movestring(str_arg):
1189 if str_arg in directions_db:
1190 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1193 print("Ignoring: Argument must be valid direction string.")
1195 if action == "move":
1196 return set_command_and_argument_movestring
1198 return set_command_and_argument_int
1203 def command_seedrandomness(seed_string):
1204 """Set rand seed to int(seed_string)."""
1205 val = integer_test(seed_string, 0, 4294967295)
1210 def command_makeworld(seed_string):
1211 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1213 Seed rand with seed. Do more only with a "wait" ThingAction and
1214 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1215 world_db["Things"] emptied, call make_map() and set
1216 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1217 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1218 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1219 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1226 err = "Space to put thing on too hard to find. Map too small?"
1228 y = rand.next() % world_db["MAP_LENGTH"]
1229 x = rand.next() % world_db["MAP_LENGTH"]
1230 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1234 raise SystemExit(err)
1235 # Replica of C code, wrongly ignores animatedness of new Thing.
1236 pos_clear = (0 == len([id for id in world_db["Things"]
1237 if world_db["Things"][id]["T_LIFEPOINTS"]
1238 if world_db["Things"][id]["T_POSY"] == y
1239 if world_db["Things"][id]["T_POSX"] == x]))
1244 val = integer_test(seed_string, 0, 4294967295)
1248 player_will_be_generated = False
1249 playertype = world_db["PLAYER_TYPE"]
1250 for ThingType in world_db["ThingTypes"]:
1251 if playertype == ThingType:
1252 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1253 player_will_be_generated = True
1255 if not player_will_be_generated:
1256 print("Ignoring: No player type with start number >0 defined.")
1259 for ThingAction in world_db["ThingActions"]:
1260 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1263 print("Ignoring beyond SEED_MAP: " +
1264 "No thing action with name 'wait' defined.")
1266 world_db["Things"] = {}
1268 world_db["WORLD_ACTIVE"] = 1
1269 world_db["TURN"] = 1
1270 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1271 id = id_setter(-1, "Things")
1272 world_db["Things"][id] = new_Thing(playertype, free_pos())
1273 if not world_db["Things"][0]["fovmap"]:
1274 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1275 world_db["Things"][0]["fovmap"] = empty_fovmap
1276 update_map_memory(world_db["Things"][0])
1277 for type in world_db["ThingTypes"]:
1278 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1279 if type != playertype:
1280 id = id_setter(-1, "Things")
1281 world_db["Things"][id] = new_Thing(type, free_pos())
1282 strong_write(io_db["file_out"], "NEW_WORLD\n")
1286 def command_maplength(maplength_string):
1287 """Redefine map length. Invalidate map, therefore lose all things on it."""
1288 val = integer_test(maplength_string, 1, 256)
1290 world_db["MAP_LENGTH"] = val
1291 world_db["MAP"] = False
1292 set_world_inactive()
1293 world_db["Things"] = {}
1294 libpr.set_maplength(val)
1297 def command_worldactive(worldactive_string):
1298 """Toggle world_db["WORLD_ACTIVE"] if possible.
1300 An active world can always be set inactive. An inactive world can only be
1301 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1302 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1303 Also call log_help().
1305 val = integer_test(worldactive_string, 0, 1)
1307 if 0 != world_db["WORLD_ACTIVE"]:
1309 set_world_inactive()
1311 print("World already active.")
1312 elif 0 == world_db["WORLD_ACTIVE"]:
1314 for ThingAction in world_db["ThingActions"]:
1315 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1318 player_exists = False
1319 for Thing in world_db["Things"]:
1321 player_exists = True
1323 if wait_exists and player_exists and world_db["MAP"]:
1324 for id in world_db["Things"]:
1325 if world_db["Things"][id]["T_LIFEPOINTS"]:
1326 build_fov_map(world_db["Things"][id])
1328 update_map_memory(world_db["Things"][id], False)
1329 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1330 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1331 world_db["Things"][0]["fovmap"] = empty_fovmap
1332 world_db["WORLD_ACTIVE"] = 1
1335 print("Ignoring: Not all conditions for world activation met.")
1338 def test_for_id_maker(object, category):
1339 """Return decorator testing for object having "id" attribute."""
1342 if hasattr(object, "id"):
1345 print("Ignoring: No " + category +
1346 " defined to manipulate yet.")
1351 def command_tid(id_string):
1352 """Set ID of Thing to manipulate. ID unused? Create new one.
1354 Default new Thing's type to the first available ThingType, others: zero.
1356 id = id_setter(id_string, "Things", command_tid)
1358 if world_db["ThingTypes"] == {}:
1359 print("Ignoring: No ThingType to settle new Thing in.")
1361 type = list(world_db["ThingTypes"].keys())[0]
1362 world_db["Things"][id] = new_Thing(type)
1365 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1369 def command_tcommand(str_int):
1370 """Set T_COMMAND of selected Thing."""
1371 val = integer_test(str_int, 0)
1373 if 0 == val or val in world_db["ThingActions"]:
1374 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1376 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1380 def command_ttype(str_int):
1381 """Set T_TYPE of selected Thing."""
1382 val = integer_test(str_int, 0)
1384 if val in world_db["ThingTypes"]:
1385 world_db["Things"][command_tid.id]["T_TYPE"] = val
1387 print("Ignoring: ThingType ID belongs to no known ThingType.")
1391 def command_tcarries(str_int):
1392 """Append int(str_int) to T_CARRIES of selected Thing.
1394 The ID int(str_int) must not be of the selected Thing, and must belong to a
1395 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1397 val = integer_test(str_int, 0)
1399 if val == command_tid.id:
1400 print("Ignoring: Thing cannot carry itself.")
1401 elif val in world_db["Things"] \
1402 and not world_db["Things"][val]["carried"]:
1403 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1404 world_db["Things"][val]["carried"] = True
1406 print("Ignoring: Thing not available for carrying.")
1407 # Note that the whole carrying structure is different from the C version:
1408 # Carried-ness is marked by a "carried" flag, not by Things containing
1409 # Things internally.
1413 def command_tmemthing(str_t, str_y, str_x):
1414 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1416 The type must fit to an existing ThingType, and the position into the map.
1418 type = integer_test(str_t, 0)
1419 posy = integer_test(str_y, 0, 255)
1420 posx = integer_test(str_x, 0, 255)
1421 if None != type and None != posy and None != posx:
1422 if type not in world_db["ThingTypes"] \
1423 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1424 print("Ignoring: Illegal value for thing type or position.")
1426 memthing = (type, posy, posx)
1427 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1430 def setter_map(maptype):
1431 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1433 If no map of maptype exists yet, initialize it with ' ' bytes first.
1436 def valid_map_line(str_int, mapline):
1437 val = integer_test(str_int, 0, 255)
1439 if val >= world_db["MAP_LENGTH"]:
1440 print("Illegal value for map line number.")
1441 elif len(mapline) != world_db["MAP_LENGTH"]:
1442 print("Map line length is unequal map width.")
1447 def nonThingMap_helper(str_int, mapline):
1448 val = valid_map_line(str_int, mapline)
1450 length = world_db["MAP_LENGTH"]
1451 if not world_db["MAP"]:
1452 map = bytearray(b' ' * (length ** 2))
1454 map = world_db["MAP"]
1455 map[val * length:(val * length) + length] = mapline.encode()
1456 if not world_db["MAP"]:
1457 world_db["MAP"] = map
1460 def ThingMap_helper(str_int, mapline):
1461 val = valid_map_line(str_int, mapline)
1463 length = world_db["MAP_LENGTH"]
1464 if not world_db["Things"][command_tid.id][maptype]:
1465 map = bytearray(b' ' * (length ** 2))
1467 map = world_db["Things"][command_tid.id][maptype]
1468 map[val * length:(val * length) + length] = mapline.encode()
1469 if not world_db["Things"][command_tid.id][maptype]:
1470 world_db["Things"][command_tid.id][maptype] = map
1472 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1476 def setter_tpos(axis):
1477 """Generate setter for T_POSX or T_POSY of selected Thing.
1479 If world is active, rebuilds animate things' fovmap, player's memory map.
1482 def helper(str_int):
1483 val = integer_test(str_int, 0, 255)
1485 if val < world_db["MAP_LENGTH"]:
1486 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1487 if world_db["WORLD_ACTIVE"] \
1488 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1489 build_fov_map(world_db["Things"][command_tid.id])
1490 if 0 == command_tid.id:
1491 update_map_memory(world_db["Things"][command_tid.id])
1493 print("Ignoring: Position is outside of map.")
1497 def command_ttid(id_string):
1498 """Set ID of ThingType to manipulate. ID unused? Create new one.
1500 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1503 id = id_setter(id_string, "ThingTypes", command_ttid)
1505 world_db["ThingTypes"][id] = {
1506 "TT_NAME": "(none)",
1509 "TT_PROLIFERATE": 0,
1510 "TT_START_NUMBER": 0,
1517 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1521 def command_ttname(name):
1522 """Set TT_NAME of selected ThingType."""
1523 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1527 def command_tttool(name):
1528 """Set TT_TOOL of selected ThingType."""
1529 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1533 def command_ttsymbol(char):
1534 """Set TT_SYMBOL of selected ThingType. """
1536 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1538 print("Ignoring: Argument must be single character.")
1542 def command_ttcorpseid(str_int):
1543 """Set TT_CORPSE_ID of selected ThingType."""
1544 val = integer_test(str_int, 0)
1546 if val in world_db["ThingTypes"]:
1547 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1549 print("Ignoring: Corpse ID belongs to no known ThignType.")
1552 def command_taid(id_string):
1553 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1555 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1557 id = id_setter(id_string, "ThingActions", command_taid, True)
1559 world_db["ThingActions"][id] = {
1565 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1568 @test_ThingAction_id
1569 def command_taname(name):
1570 """Set TA_NAME of selected ThingAction.
1572 The name must match a valid thing action function. If after the name
1573 setting no ThingAction with name "wait" remains, call set_world_inactive().
1575 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1576 or name == "pick_up":
1577 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1578 if 1 == world_db["WORLD_ACTIVE"]:
1579 wait_defined = False
1580 for id in world_db["ThingActions"]:
1581 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1584 if not wait_defined:
1585 set_world_inactive()
1587 print("Ignoring: Invalid action name.")
1588 # In contrast to the original,naming won't map a function to a ThingAction.
1592 """Call ai() on player Thing, then turn_over()."""
1593 ai(world_db["Things"][0])
1597 """Commands database.
1599 Map command start tokens to ([0]) number of expected command arguments, ([1])
1600 the command's meta-ness (i.e. is it to be written to the record file, is it to
1601 be ignored in replay mode if read from server input file), and ([2]) a function
1605 "QUIT": (0, True, command_quit),
1606 "PING": (0, True, command_ping),
1607 "THINGS_HERE": (2, True, command_thingshere),
1608 "MAKE_WORLD": (1, False, command_makeworld),
1609 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1610 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1611 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1612 "MAP_LENGTH": (1, False, command_maplength),
1613 "WORLD_ACTIVE": (1, False, command_worldactive),
1614 "MAP": (2, False, setter_map("MAP")),
1615 "TA_ID": (1, False, command_taid),
1616 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1617 "TA_NAME": (1, False, command_taname),
1618 "TT_ID": (1, False, command_ttid),
1619 "TT_NAME": (1, False, command_ttname),
1620 "TT_TOOL": (1, False, command_tttool),
1621 "TT_SYMBOL": (1, False, command_ttsymbol),
1622 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1623 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1624 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1626 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1628 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1629 "T_ID": (1, False, command_tid),
1630 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1631 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1632 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1633 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1634 "T_COMMAND": (1, False, command_tcommand),
1635 "T_TYPE": (1, False, command_ttype),
1636 "T_CARRIES": (1, False, command_tcarries),
1637 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1638 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1639 "T_MEMTHING": (3, False, command_tmemthing),
1640 "T_POSY": (1, False, setter_tpos("Y")),
1641 "T_POSX": (1, False, setter_tpos("X")),
1642 "wait": (0, False, play_commander("wait")),
1643 "move": (1, False, play_commander("move")),
1644 "pick_up": (0, False, play_commander("pick_up")),
1645 "drop": (1, False, play_commander("drop", True)),
1646 "use": (1, False, play_commander("use", True)),
1647 "ai": (0, False, command_ai)
1649 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1652 """World state database. With sane default values. (Randomness is in rand.)"""
1664 """Mapping of direction names to internal direction chars."""
1665 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1666 "west": "s", "north-west": "w", "north-east": "e"}
1668 """File IO database."""
1670 "path_save": "save",
1671 "path_record": "record_save",
1672 "path_worldconf": "confserver/world",
1673 "path_server": "server/",
1674 "path_in": "server/in",
1675 "path_out": "server/out",
1676 "path_worldstate": "server/worldstate",
1677 "tmp_suffix": "_tmp",
1678 "kicked_by_rival": False,
1679 "worldstate_updateable": False
1684 libpr = prep_library()
1685 rand = RandomnessIO()
1686 opts = parse_command_line_arguments()
1688 io_db["path_save"] = opts.savefile
1689 io_db["path_record"] = "record_" + opts.savefile
1692 io_db["verbose"] = True
1693 if None != opts.replay:
1697 except SystemExit as exit:
1698 print("ABORTING: " + exit.args[0])
1700 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")