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.
116 print("input " + prefix + ": " + command)
118 tokens = shlex.split(command, comments=True)
119 except ValueError as err:
120 print("Can't tokenize command string: " + str(err) + ".")
122 if len(tokens) > 0 and tokens[0] in commands_db \
123 and len(tokens) == commands_db[tokens[0]][0] + 1:
124 if commands_db[tokens[0]][1]:
125 commands_db[tokens[0]][2](*tokens[1:])
127 print("Due to replay mode, reading command as 'go on in record'.")
128 line = io_db["file_record"].readline()
130 obey(line.rstrip(), io_db["file_record"].prefix
131 + str(io_db["file_record"].line_n))
132 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
134 print("Reached end of record file.")
136 commands_db[tokens[0]][2](*tokens[1:])
138 io_db["record_chunk"] += command + "\n"
139 if time.time() > io_db["save_wait"] + 15:
140 atomic_write(io_db["path_record"], io_db["record_chunk"],
143 io_db["record_chunk"] = ""
144 io_db["save_wait"] = time.time()
145 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
146 elif 0 != len(tokens):
147 print("Invalid command/argument, or bad number of tokens.")
150 def atomic_write(path, text, do_append=False, delete=True):
151 """Atomic write of text to file at path, appended if do_append is set."""
152 path_tmp = path + io_db["tmp_suffix"]
156 if os.access(path, os.F_OK):
157 shutil.copyfile(path, path_tmp)
158 file = open(path_tmp, mode)
159 strong_write(file, text)
161 if delete and os.access(path, os.F_OK):
163 os.rename(path_tmp, path)
167 """Save all commands needed to reconstruct current world state."""
170 string = string.replace("\u005C", '\u005C\u005C')
171 return '"' + string.replace('"', '\u005C"') + '"'
176 if world_db["Things"][id][key]:
177 map = world_db["Things"][id][key]
178 length = world_db["MAP_LENGTH"]
179 for i in range(length):
180 line = map[i * length:(i * length) + length].decode()
181 string = string + key + " " + str(i) + " " + quote(line) \
188 for memthing in world_db["Things"][id]["T_MEMTHING"]:
189 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
190 str(memthing[1]) + " " + str(memthing[2]) + "\n"
193 def helper(category, id_string, special_keys={}):
195 for id in sorted(world_db[category].keys()):
196 string = string + id_string + " " + str(id) + "\n"
197 for key in sorted(world_db[category][id].keys()):
198 if not key in special_keys:
199 x = world_db[category][id][key]
200 argument = quote(x) if str == type(x) else str(x)
201 string = string + key + " " + argument + "\n"
202 elif special_keys[key]:
203 string = string + special_keys[key](id)
207 for key in sorted(world_db.keys()):
208 if (not isinstance(world_db[key], dict)) and key != "MAP" and \
209 key != "WORLD_ACTIVE" and key != "SEED_MAP":
210 string = string + key + " " + str(world_db[key]) + "\n"
211 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
212 string = string + helper("ThingActions", "TA_ID")
213 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
214 for id in sorted(world_db["ThingTypes"].keys()):
215 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
216 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
217 string = string + helper("Things", "T_ID",
218 {"T_CARRIES": False, "carried": False,
219 "T_MEMMAP": mapsetter("T_MEMMAP"),
220 "T_MEMTHING": memthing, "fovmap": False,
221 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
222 for id in sorted(world_db["Things"].keys()):
223 if [] != world_db["Things"][id]["T_CARRIES"]:
224 string = string + "T_ID " + str(id) + "\n"
225 for carried in sorted(world_db["Things"][id]["T_CARRIES"].keys()):
226 string = string + "T_CARRIES " + str(carried) + "\n"
227 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
228 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
229 atomic_write(io_db["path_save"], string)
232 def obey_lines_in_file(path, name, do_record=False):
233 """Call obey() on each line of path's file, use name in input prefix."""
234 file = open(path, "r")
236 for line in file.readlines():
237 obey(line.rstrip(), name + "file line " + str(line_n),
243 def parse_command_line_arguments():
244 """Return settings values read from command line arguments."""
245 parser = argparse.ArgumentParser()
246 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
248 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
250 parser.add_argument('-v', dest='verbose', action='store_true')
251 opts, unknown = parser.parse_known_args()
256 """Ensure valid server out file belonging to current process.
258 This is done by comparing io_db["teststring"] to what's found at the start
259 of the current file at io_db["path_out"]. On failure, set
260 io_db["kicked_by_rival"] and raise SystemExit.
262 if not os.access(io_db["path_out"], os.F_OK):
263 raise SystemExit("Server output file has disappeared.")
264 file = open(io_db["path_out"], "r")
265 test = file.readline().rstrip("\n")
267 if test != io_db["teststring"]:
268 io_db["kicked_by_rival"] = True
269 msg = "Server test string in server output file does not match. This" \
270 " indicates that the current server process has been " \
271 "superseded by another one."
272 raise SystemExit(msg)
276 """Return next newline-delimited command from server in file.
278 Keep building return string until a newline is encountered. Pause between
279 unsuccessful reads, and after too much waiting, run server_test().
281 wait_on_fail = 0.03333
286 add = io_db["file_in"].readline()
288 command = command + add
289 if len(command) > 0 and "\n" == command[-1]:
290 command = command[:-1]
293 time.sleep(wait_on_fail)
294 if now + max_wait < time.time():
300 def try_worldstate_update():
301 """Write worldstate file if io_db["worldstate_updateable"] is set."""
302 if io_db["worldstate_updateable"]:
304 def draw_visible_Things(map, run):
305 for id in world_db["Things"]:
306 type = world_db["Things"][id]["T_TYPE"]
307 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
308 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
309 if (0 == run and not consumable and not alive) \
310 or (1 == run and consumable and not alive) \
311 or (2 == run and alive):
312 y = world_db["Things"][id]["T_POSY"]
313 x = world_db["Things"][id]["T_POSX"]
314 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
315 if 'v' == chr(fovflag):
316 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
317 map[(y * length) + x] = ord(c)
319 def write_map(string, map):
320 for i in range(length):
321 line = map[i * length:(i * length) + length].decode()
322 string = string + line + "\n"
326 if [] == world_db["Things"][0]["T_CARRIES"]:
327 inventory = "(none)\n"
329 for id in world_db["Things"][0]["T_CARRIES"]:
330 type_id = world_db["Things"][id]["T_TYPE"]
331 name = world_db["ThingTypes"][type_id]["TT_NAME"]
332 inventory = inventory + name + "\n"
333 string = str(world_db["TURN"]) + "\n" + \
334 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
335 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
336 inventory + "%\n" + \
337 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
338 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
339 str(world_db["MAP_LENGTH"]) + "\n"
340 length = world_db["MAP_LENGTH"]
341 fov = bytearray(b' ' * (length ** 2))
342 for pos in range(length ** 2):
343 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
344 fov[pos] = world_db["MAP"][pos]
346 draw_visible_Things(fov, i)
347 string = write_map(string, fov)
348 mem = world_db["Things"][0]["T_MEMMAP"][:]
350 for mt in world_db["Things"][0]["T_MEMTHING"]:
351 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
352 if (i == 0 and not consumable) or (i == 1 and consumable):
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).
421 def is_neighbor(coordinates, type):
424 length = world_db["MAP_LENGTH"]
426 diag_west = x + (ind > 0)
427 diag_east = x + (ind < (length - 1))
428 pos = (y * length) + x
429 if (y > 0 and diag_east
430 and type == chr(world_db["MAP"][pos - length + ind])) \
432 and type == chr(world_db["MAP"][pos + 1])) \
433 or (y < (length - 1) and diag_east
434 and type == chr(world_db["MAP"][pos + length + ind])) \
435 or (y > 0 and diag_west
436 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
438 and type == chr(world_db["MAP"][pos - 1])) \
439 or (y < (length - 1) and diag_west
440 and type == chr(world_db["MAP"][pos + length - (not ind)])):
443 store_seed = rand.seed
444 rand.seed = world_db["SEED_MAP"]
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 rand.seed = store_seed
469 # This all-too-precise replica of the original C code misses iter_limit().
472 def update_map_memory(t, age_map=True):
473 """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)
489 if not t["T_MEMMAP"]:
490 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
491 if not t["T_MEMDEPTHMAP"]:
492 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 if ord_space == t["T_MEMMAP"][pos]:
500 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
502 age_some_memdepthmap_on_nonfov_cells()
503 for mt in [mt for mt in t["T_MEMTHING"]
504 if ord_v == t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
506 t["T_MEMTHING"].remove(mt)
507 for id in [id for id in world_db["Things"]
508 if not world_db["Things"][id]["carried"]]:
509 type = world_db["Things"][id]["T_TYPE"]
510 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
511 y = world_db["Things"][id]["T_POSY"]
512 x = world_db["Things"][id]["T_POSX"]
513 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
514 t["T_MEMTHING"].append((type, y, x))
517 def set_world_inactive():
518 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
520 if os.access(io_db["path_worldstate"], os.F_OK):
521 os.remove(io_db["path_worldstate"])
522 world_db["WORLD_ACTIVE"] = 0
525 def integer_test(val_string, min, max=None):
526 """Return val_string if integer >= min & (if max set) <= max, else None."""
528 val = int(val_string)
529 if val < min or (max is not None and val > max):
533 msg = "Ignoring: Please use integer >= " + str(min)
535 msg += " and <= " + str(max)
541 def setter(category, key, min, max=None):
542 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
545 val = integer_test(val_string, min, max)
549 if category == "Thing":
550 id_store = command_tid
551 decorator = test_Thing_id
552 elif category == "ThingType":
553 id_store = command_ttid
554 decorator = test_ThingType_id
555 elif category == "ThingAction":
556 id_store = command_taid
557 decorator = test_ThingAction_id
561 val = integer_test(val_string, min, max)
563 world_db[category + "s"][id_store.id][key] = val
567 def build_fov_map(t):
568 """Build Thing's FOV map."""
569 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
570 fovmap = c_pointer_to_bytearray(t["fovmap"])
571 map = c_pointer_to_bytearray(world_db["MAP"])
572 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
573 raise RuntimeError("Malloc error in build_fov_Map().")
576 def decrement_lifepoints(t):
577 """Decrement t's lifepoints by 1, and if to zero, corpse it.
579 If t is the player avatar, only blank its fovmap, so that the client may
580 still display memory data. On non-player things, erase fovmap and memory.
582 t["T_LIFEPOINTS"] -= 1
583 if 0 == t["T_LIFEPOINTS"]:
584 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
585 if world_db["Things"][0] == t:
586 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
587 strong_write(io_db["file_out"], "LOG You die.\n")
590 t["T_MEMMAP"] = False
591 t["T_MEMDEPTHMAP"] = False
593 strong_write(io_db["file_out"], "LOG It dies.\n")
596 def mv_yx_in_dir_legal(dir, y, x):
597 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
598 dir_c = dir.encode("ascii")[0]
599 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
601 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
602 return (test, libpr.result_y(), libpr.result_x())
606 """Make t do nothing (but loudly, if player avatar)."""
607 if t == world_db["Things"][0]:
608 strong_write(io_db["file_out"], "LOG You wait.\n")
612 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
614 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
615 t["T_POSY"], t["T_POSX"])
616 if 1 == move_result[0]:
617 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
618 passable = "." == chr(world_db["MAP"][pos])
619 hitted = [id for id in world_db["Things"]
620 if world_db["Things"][id] != t
621 if world_db["Things"][id]["T_LIFEPOINTS"]
622 if world_db["Things"][id]["T_POSY"] == move_result[1]
623 if world_db["Things"][id]["T_POSX"] == move_result[2]]
626 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
627 hitter = "You" if t == world_db["Things"][0] else hitter_name
628 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
629 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
630 hitted = "you" if hit_id == 0 else hitted_name
631 verb = " wound " if hitter == "You" else " wounds "
632 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
634 decrement_lifepoints(world_db["Things"][hit_id])
636 dir = [dir for dir in directions_db
637 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
639 t["T_POSY"] = move_result[1]
640 t["T_POSX"] = move_result[2]
641 for id in t["T_CARRIES"]:
642 world_db["Things"][id]["T_POSY"] = move_result[1]
643 world_db["Things"][id]["T_POSX"] = move_result[2]
645 if t == world_db["Things"][0]:
646 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
647 elif t == world_db["Things"][0]:
648 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
651 def actor_pick_up(t):
652 """Make t pick up (topmost?) Thing from ground into inventory."""
653 # Topmostness is actually not defined so far. Picks Thing with highest ID.
654 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
655 if not world_db["Things"][id]["carried"]
656 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
657 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
663 world_db["Things"][highest_id]["carried"] = True
664 t["T_CARRIES"].append(highest_id)
665 if t == world_db["Things"][0]:
666 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
667 elif t == world_db["Things"][0]:
668 err = "You try to pick up an object, but there is none."
669 strong_write(io_db["file_out"], "LOG " + err + "\n")
673 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
674 # TODO: Handle case where T_ARGUMENT matches nothing.
675 if len(t["T_CARRIES"]):
676 id = t["T_CARRIES"][t["T_ARGUMENT"]]
677 t["T_CARRIES"].remove(id)
678 world_db["Things"][id]["carried"] = False
679 if t == world_db["Things"][0]:
680 strong_write(io_db["file_out"], "LOG You drop an object.\n")
681 elif t == world_db["Things"][0]:
682 err = "You try to drop an object, but you own none."
683 strong_write(io_db["file_out"], "LOG " + err + "\n")
687 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
688 # TODO: Handle case where T_ARGUMENT matches nothing.
689 if len(t["T_CARRIES"]):
690 id = t["T_CARRIES"][t["T_ARGUMENT"]]
691 type = world_db["Things"][id]["T_TYPE"]
692 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
693 t["T_CARRIES"].remove(id)
694 del world_db["Things"][id]
695 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
696 if t == world_db["Things"][0]:
697 strong_write(io_db["file_out"],
698 "LOG You consume this object.\n")
699 elif t == world_db["Things"][0]:
700 strong_write(io_db["file_out"],
701 "LOG You try to use this object, but fail.\n")
702 elif t == world_db["Things"][0]:
703 strong_write(io_db["file_out"],
704 "LOG You try to use an object, but you own none.\n")
707 def thingproliferation(t):
708 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
710 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
711 passable and not be inhabited by a Thing of the same type, or, if Thing is
712 animate, any other animate Thing. If there are several map cell candidates,
713 one is selected randomly.
715 def test_cell(t, y, x):
716 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
717 for id in [id for id in world_db["Things"]
718 if y == world_db["Things"][id]["T_POSY"]
719 if x == world_db["Things"][id]["T_POSX"]
720 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
721 or (t["T_LIFEPOINTS"] and
722 world_db["Things"][id]["T_LIFEPOINTS"])]:
726 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
727 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
729 for dir in [directions_db[key] for key in directions_db]:
730 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
731 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
732 candidates.append((mv_result[1], mv_result[2]))
734 i = rand.next() % len(candidates)
735 id = id_setter(-1, "Things")
736 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
737 world_db["Things"][id] = newT
741 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
743 On success, decrease satiation score by 32.
745 if t["T_SATIATION"] > 0 \
746 and t["T_LIFEPOINTS"] < \
747 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
748 and 0 == (rand.next() % 31) \
749 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
750 if world_db["ThingActions"][id]["TA_NAME"] ==
752 t["T_LIFEPOINTS"] += 1
753 t["T_SATIATION"] -= 32
754 if t == world_db["Things"][0]:
755 strong_write(io_db["file_out"], "LOG You heal.\n")
757 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
758 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
762 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
763 if t["T_SATIATION"] > -32768:
764 t["T_SATIATION"] -= 1
765 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
766 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
767 raise RuntimeError("A thing that should not hunger is hungering.")
768 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
769 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
770 if t == world_db["Things"][0]:
771 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
773 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
774 strong_write(io_db["file_out"], "LOG " + name +
775 " suffers from hunger.\n")
776 decrement_lifepoints(t)
779 def get_dir_to_target(t, filter):
780 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
782 The path-wise nearest target is chosen, via the shortest available path.
783 Target must not be t. On succcess, return positive value, else False.
785 "a": Thing in FOV is below a certain distance, animate, but of ThingType
786 that is not t's, and starts out weaker than t is; build path as
787 avoiding things of t's ThingType
788 "f": neighbor cell (not inhabited by any animate Thing) further away from
789 animate Thing not further than x steps away and in FOV and of a
790 ThingType that is not t's, and starts out stronger or as strong as t
791 is currently; or (cornered), if no such flight cell, but Thing of
792 above criteria is too near,1 a cell closer to it, or, if less near,
794 "c": Thing in memorized map is consumable
795 "s": memory map cell with greatest-reachable degree of unexploredness
798 def zero_score_map_where_char_on_memdepthmap(c):
799 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
800 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
801 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
802 # set_map_score(i, 0)
803 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
804 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
805 raise RuntimeError("No score map allocated for "
806 "zero_score_map_where_char_on_memdepthmap().")
808 def set_map_score(pos, score):
809 test = libpr.set_map_score(pos, score)
811 raise RuntimeError("No score map allocated for set_map_score().")
813 def get_map_score(pos):
814 result = libpr.get_map_score(pos)
816 raise RuntimeError("No score map allocated for get_map_score().")
820 if t["fovmap"] and ("a" == filter or "f" == filter):
821 for id in world_db["Things"]:
822 Thing = world_db["Things"][id]
823 if Thing != t and Thing["T_LIFEPOINTS"] and \
824 t["T_TYPE"] != Thing["T_TYPE"] and \
825 'v' == chr(t["fovmap"][(Thing["T_POSY"]
826 * world_db["MAP_LENGTH"])
828 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
829 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
831 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
834 elif t["T_MEMMAP"] and "c" == filter:
835 for mt in t["T_MEMTHING"]:
836 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
838 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
842 def set_cells_passable_on_memmap_to_65534_on_scoremap():
843 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
845 # memmap = t["T_MEMMAP"]
846 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
847 # if ord_dot == memmap[i]]:
848 # set_map_score(i, 65534) # i.e. 65535-1
849 map = c_pointer_to_bytearray(t["T_MEMMAP"])
850 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
851 raise RuntimeError("No score map allocated for set_cells_passable"
852 "_on_memmap_to_65534_on_scoremap().")
854 def init_score_map():
855 test = libpr.init_score_map()
857 raise RuntimeError("Malloc error in init_score_map().")
860 set_cells_passable_on_memmap_to_65534_on_scoremap()
862 for id in world_db["Things"]:
863 Thing = world_db["Things"][id]
864 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
866 if t != Thing and Thing["T_LIFEPOINTS"] and \
867 t["T_TYPE"] != Thing["T_TYPE"] and \
868 ord_v == t["fovmap"][pos] and \
869 t["T_LIFEPOINTS"] > \
870 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
871 set_map_score(pos, 0)
872 elif t["T_TYPE"] == Thing["T_TYPE"]:
873 set_map_score(pos, 65535)
875 for id in [id for id in world_db["Things"]
876 if world_db["Things"][id]["T_LIFEPOINTS"]]:
877 Thing = world_db["Things"][id]
878 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
880 if t["T_TYPE"] != Thing["T_TYPE"] and \
881 ord_v == t["fovmap"][pos] and \
882 t["T_LIFEPOINTS"] <= \
883 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
884 set_map_score(pos, 0)
886 for mt in [mt for mt in t["T_MEMTHING"]
887 if ord_blank != t["T_MEMMAP"][mt[1]
888 * world_db["MAP_LENGTH"]
890 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
891 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
893 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
895 def rand_target_dir(neighbors, cmp, dirs):
898 for i in range(len(dirs)):
899 if cmp == neighbors[i]:
900 candidates.append(dirs[i])
902 return candidates[rand.next() % n_candidates] if n_candidates else 0
904 def get_neighbor_scores(dirs, eye_pos):
906 if libpr.ready_neighbor_scores(eye_pos):
907 raise RuntimeError("No score map allocated for " +
908 "ready_neighbor_scores.()")
909 for i in range(len(dirs)):
910 scores.append(libpr.get_neighbor_score(i))
913 def get_dir_from_neighbors():
914 dir_to_target = False
916 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
917 neighbors = get_neighbor_scores(dirs, eye_pos)
919 inhabited = [world_db["Things"][id]["T_POSY"]
920 * world_db["MAP_LENGTH"]
921 + world_db["Things"][id]["T_POSX"]
922 for id in world_db["Things"]
923 if world_db["Things"][id]["T_LIFEPOINTS"]]
924 for i in range(len(dirs)):
925 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
926 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
928 for pos in [pos for pos in inhabited if pos == pos_cmp]:
931 minmax_start = 0 if "f" == filter else 65535 - 1
932 minmax_neighbor = minmax_start
933 for i in range(len(dirs)):
934 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
935 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
936 or ("f" != filter and minmax_neighbor > neighbors[i]):
937 minmax_neighbor = neighbors[i]
938 if minmax_neighbor != minmax_start:
939 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
941 if not dir_to_target:
942 if 1 == get_map_score(eye_pos):
943 dir_to_target = rand_target_dir(neighbors, 0, dirs)
944 elif 3 >= get_map_score(eye_pos):
945 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
947 world_db["ThingActions"][id]["TA_NAME"]
950 elif dir_to_target and 3 < get_map_score(eye_pos):
952 elif "a" == filter and 10 <= get_map_score(eye_pos):
956 dir_to_target = False
958 run_i = 9 + 1 if "s" == filter else 1
959 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
962 mem_depth_c = b'9' if b' ' == mem_depth_c \
963 else bytes([mem_depth_c[0] - 1])
964 if libpr.dijkstra_map():
965 raise RuntimeError("No score map allocated for dijkstra_map().")
966 dir_to_target = get_dir_from_neighbors()
967 libpr.free_score_map()
968 if dir_to_target and str == type(dir_to_target):
969 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
970 if world_db["ThingActions"][id]["TA_NAME"]
972 t["T_ARGUMENT"] = ord(dir_to_target)
976 def standing_on_consumable(t):
977 """Return True/False whether t is standing on a consumable."""
978 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
979 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
980 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
981 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
987 def get_inventory_slot_to_consume(t):
988 """Return slot Id of strongest consumable in t's inventory, else -1."""
989 cmp_consumability = 0
992 for id in t["T_CARRIES"]:
993 type = world_db["Things"][id]["T_TYPE"]
994 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
995 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1002 """Determine next command/argment for actor t via AI algorithms.
1004 AI will look for, and move towards, enemies (animate Things not of their
1005 own ThingType); if they see none, they will consume consumables in their
1006 inventory; if there are none, they will pick up what they stand on if they
1007 stand on consumables; if they stand on none, they will move towards the
1008 next consumable they see or remember on the map; if they see or remember
1009 none, they will explore parts of the map unseen since ever or for at least
1010 one turn; if there is nothing to explore, they will simply wait.
1012 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1013 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1014 if not get_dir_to_target(t, "f"):
1015 sel = get_inventory_slot_to_consume(t)
1017 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1018 if world_db["ThingActions"][id]["TA_NAME"]
1020 t["T_ARGUMENT"] = sel
1021 elif standing_on_consumable(t):
1022 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1023 if world_db["ThingActions"][id]["TA_NAME"]
1025 elif (not get_dir_to_target(t, "c")) and \
1026 (not get_dir_to_target(t, "a")):
1027 get_dir_to_target(t, "s")
1031 """Run game world and its inhabitants until new player input expected."""
1033 whilebreaker = False
1034 while world_db["Things"][0]["T_LIFEPOINTS"]:
1035 for id in [id for id in world_db["Things"]]: # Only what's from start!
1036 if not id in world_db["Things"] or \
1037 world_db["Things"][id]["carried"]: # May have been consumed or
1038 continue # picked up during turn …
1039 Thing = world_db["Things"][id]
1040 if Thing["T_LIFEPOINTS"]:
1041 if not Thing["T_COMMAND"]:
1042 update_map_memory(Thing)
1048 Thing["T_PROGRESS"] += 1
1049 taid = [a for a in world_db["ThingActions"]
1050 if a == Thing["T_COMMAND"]][0]
1051 ThingAction = world_db["ThingActions"][taid]
1052 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1053 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1054 Thing["T_COMMAND"] = 0
1055 Thing["T_PROGRESS"] = 0
1057 thingproliferation(Thing)
1060 world_db["TURN"] += 1
1063 def new_Thing(type, pos=(0, 0)):
1064 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1066 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1078 "T_MEMDEPTHMAP": False,
1081 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1082 build_fov_map(thing)
1086 def id_setter(id, category, id_store=False, start_at_1=False):
1087 """Set ID of object of category to manipulate ID unused? Create new one.
1088 The ID is stored as id_store.id (if id_store is set). If the integer of the
1089 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1090 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1091 always returned when no new object is created, else the new object's ID.
1093 min = 0 if start_at_1 else -1
1095 id = integer_test(id, min)
1097 if id in world_db[category]:
1102 if (start_at_1 and 0 == id) \
1103 or ((not start_at_1) and (id < 0)):
1104 id = 0 if start_at_1 else -1
1107 if id not in world_db[category]:
1115 """Send PONG line to server output file."""
1116 strong_write(io_db["file_out"], "PONG\n")
1120 """Abort server process."""
1122 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1123 raise SystemExit("received QUIT command")
1126 def command_thingshere(str_y, str_x):
1127 """Write to out file list of Things known to player at coordinate y, x."""
1128 if world_db["WORLD_ACTIVE"]:
1129 y = integer_test(str_y, 0, 255)
1130 x = integer_test(str_x, 0, 255)
1131 length = world_db["MAP_LENGTH"]
1132 if None != y and None != x and y < length and x < length:
1133 pos = (y * world_db["MAP_LENGTH"]) + x
1134 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1135 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1136 for id in world_db["Things"]:
1137 if y == world_db["Things"][id]["T_POSY"] \
1138 and x == world_db["Things"][id]["T_POSX"] \
1139 and not world_db["Things"][id]["carried"]:
1140 type = world_db["Things"][id]["T_TYPE"]
1141 name = world_db["ThingTypes"][type]["TT_NAME"]
1142 strong_write(io_db["file_out"], name + "\n")
1144 for mt in world_db["Things"][0]["T_MEMTHING"]:
1145 if y == mt[1] and x == mt[2]:
1146 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1147 strong_write(io_db["file_out"], name + "\n")
1148 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1150 print("Ignoring: Invalid map coordinates.")
1152 print("Ignoring: Command only works on existing worlds.")
1155 def play_commander(action, args=False):
1156 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1158 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1162 id = [x for x in world_db["ThingActions"]
1163 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1164 world_db["Things"][0]["T_COMMAND"] = id
1167 def set_command_and_argument_int(str_arg):
1168 val = integer_test(str_arg, 0, 255)
1170 world_db["Things"][0]["T_ARGUMENT"] = val
1173 def set_command_and_argument_movestring(str_arg):
1174 if str_arg in directions_db:
1175 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1178 print("Ignoring: Argument must be valid direction string.")
1180 if action == "move":
1181 return set_command_and_argument_movestring
1183 return set_command_and_argument_int
1188 def command_seedrandomness(seed_string):
1189 """Set rand seed to int(seed_string)."""
1190 val = integer_test(seed_string, 0, 4294967295)
1195 def command_seedmap(seed_string):
1196 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1197 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1201 def command_makeworld(seed_string):
1202 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1204 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1205 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1206 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1207 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1208 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1209 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1210 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1216 err = "Space to put thing on too hard to find. Map too small?"
1218 y = rand.next() % world_db["MAP_LENGTH"]
1219 x = rand.next() % world_db["MAP_LENGTH"]
1220 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1224 raise SystemExit(err)
1225 # Replica of C code, wrongly ignores animatedness of new Thing.
1226 pos_clear = (0 == len([id for id in world_db["Things"]
1227 if world_db["Things"][id]["T_LIFEPOINTS"]
1228 if world_db["Things"][id]["T_POSY"] == y
1229 if world_db["Things"][id]["T_POSX"] == x]))
1234 val = integer_test(seed_string, 0, 4294967295)
1238 world_db["SEED_MAP"] = val
1239 player_will_be_generated = False
1240 playertype = world_db["PLAYER_TYPE"]
1241 for ThingType in world_db["ThingTypes"]:
1242 if playertype == ThingType:
1243 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1244 player_will_be_generated = True
1246 if not player_will_be_generated:
1247 print("Ignoring beyond SEED_MAP: " +
1248 "No player type with start number >0 defined.")
1251 for ThingAction in world_db["ThingActions"]:
1252 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1255 print("Ignoring beyond SEED_MAP: " +
1256 "No thing action with name 'wait' defined.")
1258 world_db["Things"] = {}
1260 world_db["WORLD_ACTIVE"] = 1
1261 world_db["TURN"] = 1
1262 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1263 id = id_setter(-1, "Things")
1264 world_db["Things"][id] = new_Thing(playertype, free_pos())
1265 update_map_memory(world_db["Things"][0])
1266 for type in world_db["ThingTypes"]:
1267 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1268 if type != playertype:
1269 id = id_setter(-1, "Things")
1270 world_db["Things"][id] = new_Thing(type, free_pos())
1271 strong_write(io_db["file_out"], "NEW_WORLD\n")
1274 def command_maplength(maplength_string):
1275 """Redefine map length. Invalidate map, therefore lose all things on it."""
1276 val = integer_test(maplength_string, 1, 256)
1278 world_db["MAP_LENGTH"] = val
1279 set_world_inactive()
1280 world_db["Things"] = {}
1281 libpr.set_maplength(val)
1284 def command_worldactive(worldactive_string):
1285 """Toggle world_db["WORLD_ACTIVE"] if possible.
1287 An active world can always be set inactive. An inactive world can only be
1288 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1289 activation, rebuild all Things' FOVs, and the player's map memory.
1291 # In original version, map existence was also tested (unnecessarily?).
1292 val = integer_test(worldactive_string, 0, 1)
1294 if 0 != world_db["WORLD_ACTIVE"]:
1296 set_world_inactive()
1298 print("World already active.")
1299 elif 0 == world_db["WORLD_ACTIVE"]:
1301 for ThingAction in world_db["ThingActions"]:
1302 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1305 player_exists = False
1306 for Thing in world_db["Things"]:
1308 player_exists = True
1310 if wait_exists and player_exists:
1311 for id in world_db["Things"]:
1312 if world_db["Things"][id]["T_LIFEPOINTS"]:
1313 build_fov_map(world_db["Things"][id])
1315 update_map_memory(world_db["Things"][id], False)
1316 world_db["WORLD_ACTIVE"] = 1
1319 def test_for_id_maker(object, category):
1320 """Return decorator testing for object having "id" attribute."""
1323 if hasattr(object, "id"):
1326 print("Ignoring: No " + category +
1327 " defined to manipulate yet.")
1332 def command_tid(id_string):
1333 """Set ID of Thing to manipulate. ID unused? Create new one.
1335 Default new Thing's type to the first available ThingType, others: zero.
1337 id = id_setter(id_string, "Things", command_tid)
1339 if world_db["ThingTypes"] == {}:
1340 print("Ignoring: No ThingType to settle new Thing in.")
1342 type = list(world_db["ThingTypes"].keys())[0]
1343 world_db["Things"][id] = new_Thing(type)
1346 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1350 def command_tcommand(str_int):
1351 """Set T_COMMAND of selected Thing."""
1352 val = integer_test(str_int, 0)
1354 if 0 == val or val in world_db["ThingActions"]:
1355 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1357 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1361 def command_ttype(str_int):
1362 """Set T_TYPE of selected Thing."""
1363 val = integer_test(str_int, 0)
1365 if val in world_db["ThingTypes"]:
1366 world_db["Things"][command_tid.id]["T_TYPE"] = val
1368 print("Ignoring: ThingType ID belongs to no known ThingType.")
1372 def command_tcarries(str_int):
1373 """Append int(str_int) to T_CARRIES of selected Thing.
1375 The ID int(str_int) must not be of the selected Thing, and must belong to a
1376 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1378 val = integer_test(str_int, 0)
1380 if val == command_tid.id:
1381 print("Ignoring: Thing cannot carry itself.")
1382 elif val in world_db["Things"] \
1383 and not world_db["Things"][val]["carried"]:
1384 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1385 world_db["Things"][val]["carried"] = True
1387 print("Ignoring: Thing not available for carrying.")
1388 # Note that the whole carrying structure is different from the C version:
1389 # Carried-ness is marked by a "carried" flag, not by Things containing
1390 # Things internally.
1394 def command_tmemthing(str_t, str_y, str_x):
1395 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1397 The type must fit to an existing ThingType, and the position into the map.
1399 type = integer_test(str_t, 0)
1400 posy = integer_test(str_y, 0, 255)
1401 posx = integer_test(str_x, 0, 255)
1402 if None != type and None != posy and None != posx:
1403 if type not in world_db["ThingTypes"] \
1404 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1405 print("Ignoring: Illegal value for thing type or position.")
1407 memthing = (type, posy, posx)
1408 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1411 def setter_map(maptype):
1412 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1414 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1417 def helper(str_int, mapline):
1418 val = integer_test(str_int, 0, 255)
1420 if val >= world_db["MAP_LENGTH"]:
1421 print("Illegal value for map line number.")
1422 elif len(mapline) != world_db["MAP_LENGTH"]:
1423 print("Map line length is unequal map width.")
1425 length = world_db["MAP_LENGTH"]
1427 if not world_db["Things"][command_tid.id][maptype]:
1428 map = bytearray(b' ' * (length ** 2))
1430 map = world_db["Things"][command_tid.id][maptype]
1431 map[val * length:(val * length) + length] = mapline.encode()
1432 world_db["Things"][command_tid.id][maptype] = map
1436 def setter_tpos(axis):
1437 """Generate setter for T_POSX or T_POSY of selected Thing.
1439 If world is active, rebuilds animate things' fovmap, player's memory map.
1442 def helper(str_int):
1443 val = integer_test(str_int, 0, 255)
1445 if val < world_db["MAP_LENGTH"]:
1446 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1447 if world_db["WORLD_ACTIVE"] \
1448 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1449 build_fov_map(world_db["Things"][command_tid.id])
1450 if 0 == command_tid.id:
1451 update_map_memory(world_db["Things"][command_tid.id])
1453 print("Ignoring: Position is outside of map.")
1457 def command_ttid(id_string):
1458 """Set ID of ThingType to manipulate. ID unused? Create new one.
1460 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1462 id = id_setter(id_string, "ThingTypes", command_ttid)
1464 world_db["ThingTypes"][id] = {
1465 "TT_NAME": "(none)",
1468 "TT_PROLIFERATE": 0,
1469 "TT_START_NUMBER": 0,
1475 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1479 def command_ttname(name):
1480 """Set TT_NAME of selected ThingType."""
1481 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1485 def command_ttsymbol(char):
1486 """Set TT_SYMBOL of selected ThingType. """
1488 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1490 print("Ignoring: Argument must be single character.")
1494 def command_ttcorpseid(str_int):
1495 """Set TT_CORPSE_ID of selected ThingType."""
1496 val = integer_test(str_int, 0)
1498 if val in world_db["ThingTypes"]:
1499 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1501 print("Ignoring: Corpse ID belongs to no known ThignType.")
1504 def command_taid(id_string):
1505 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1507 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1509 id = id_setter(id_string, "ThingActions", command_taid, True)
1511 world_db["ThingActions"][id] = {
1517 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1520 @test_ThingAction_id
1521 def command_taname(name):
1522 """Set TA_NAME of selected ThingAction.
1524 The name must match a valid thing action function. If after the name
1525 setting no ThingAction with name "wait" remains, call set_world_inactive().
1527 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1528 or name == "pick_up":
1529 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1530 if 1 == world_db["WORLD_ACTIVE"]:
1531 wait_defined = False
1532 for id in world_db["ThingActions"]:
1533 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1536 if not wait_defined:
1537 set_world_inactive()
1539 print("Ignoring: Invalid action name.")
1540 # In contrast to the original,naming won't map a function to a ThingAction.
1544 """Call ai() on player Thing, then turn_over()."""
1545 ai(world_db["Things"][0])
1549 """Commands database.
1551 Map command start tokens to ([0]) number of expected command arguments, ([1])
1552 the command's meta-ness (i.e. is it to be written to the record file, is it to
1553 be ignored in replay mode if read from server input file), and ([2]) a function
1557 "QUIT": (0, True, command_quit),
1558 "PING": (0, True, command_ping),
1559 "THINGS_HERE": (2, True, command_thingshere),
1560 "MAKE_WORLD": (1, False, command_makeworld),
1561 "SEED_MAP": (1, False, command_seedmap),
1562 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1563 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1564 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1565 "MAP_LENGTH": (1, False, command_maplength),
1566 "WORLD_ACTIVE": (1, False, command_worldactive),
1567 "TA_ID": (1, False, command_taid),
1568 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1569 "TA_NAME": (1, False, command_taname),
1570 "TT_ID": (1, False, command_ttid),
1571 "TT_NAME": (1, False, command_ttname),
1572 "TT_SYMBOL": (1, False, command_ttsymbol),
1573 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1574 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1576 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1578 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1580 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1581 "T_ID": (1, False, command_tid),
1582 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1583 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1584 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1585 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1586 "T_COMMAND": (1, False, command_tcommand),
1587 "T_TYPE": (1, False, command_ttype),
1588 "T_CARRIES": (1, False, command_tcarries),
1589 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1590 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1591 "T_MEMTHING": (3, False, command_tmemthing),
1592 "T_POSY": (1, False, setter_tpos("Y")),
1593 "T_POSX": (1, False, setter_tpos("X")),
1594 "wait": (0, False, play_commander("wait")),
1595 "move": (1, False, play_commander("move")),
1596 "pick_up": (0, False, play_commander("pick_up")),
1597 "drop": (1, False, play_commander("drop", True)),
1598 "use": (1, False, play_commander("use", True)),
1599 "ai": (0, False, command_ai)
1603 """World state database. With sane default values. (Randomness is in rand.)"""
1615 """Mapping of direction names to internal direction chars."""
1616 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1617 "west": "s", "north-west": "w", "north-east": "e"}
1619 """File IO database."""
1621 "path_save": "save",
1622 "path_record": "record_save",
1623 "path_worldconf": "confserver/world",
1624 "path_server": "server/",
1625 "path_in": "server/in",
1626 "path_out": "server/out",
1627 "path_worldstate": "server/worldstate",
1628 "tmp_suffix": "_tmp",
1629 "kicked_by_rival": False,
1630 "worldstate_updateable": False
1635 libpr = prep_library()
1636 rand = RandomnessIO()
1637 opts = parse_command_line_arguments()
1639 io_db["path_save"] = opts.savefile
1640 io_db["path_record"] = "record_" + opts.savefile
1643 io_db["verbose"] = True
1644 if None != opts.replay:
1648 except SystemExit as exit:
1649 print("ABORTING: " + exit.args[0])
1651 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")