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 dict != type(world_db[key]) 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 if not t["T_MEMMAP"]:
475 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
476 if not t["T_MEMDEPTHMAP"]:
477 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
481 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
482 if ord_v == t["fovmap"][pos]]:
483 t["T_MEMDEPTHMAP"][pos] = ord_0
484 if ord_space == t["T_MEMMAP"][pos]:
485 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
487 maptype = ctypes.c_char * len(t["T_MEMDEPTHMAP"])
488 memdepthmap = maptype.from_buffer(t["T_MEMDEPTHMAP"])
489 fovmap = maptype.from_buffer(t["fovmap"])
490 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
491 for mt in [mt for mt in t["T_MEMTHING"]
492 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
494 t["T_MEMTHING"].remove(mt)
495 for id in [id for id in world_db["Things"]
496 if not world_db["Things"][id]["carried"]]:
497 type = world_db["Things"][id]["T_TYPE"]
498 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
499 y = world_db["Things"][id]["T_POSY"]
500 x = world_db["Things"][id]["T_POSX"]
501 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
502 t["T_MEMTHING"].append((type, y, x))
505 def set_world_inactive():
506 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
508 if os.access(io_db["path_worldstate"], os.F_OK):
509 os.remove(io_db["path_worldstate"])
510 world_db["WORLD_ACTIVE"] = 0
513 def integer_test(val_string, min, max=None):
514 """Return val_string if integer >= min & (if max set) <= max, else None."""
516 val = int(val_string)
517 if val < min or (max != None and val > max):
521 msg = "Ignoring: Please use integer >= " + str(min)
523 msg += " and <= " + str(max)
529 def setter(category, key, min, max=None):
530 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
533 val = integer_test(val_string, min, max)
537 if category == "Thing":
538 id_store = command_tid
539 decorator = test_Thing_id
540 elif category == "ThingType":
541 id_store = command_ttid
542 decorator = test_ThingType_id
543 elif category == "ThingAction":
544 id_store = command_taid
545 decorator = test_ThingAction_id
549 val = integer_test(val_string, min, max)
551 world_db[category + "s"][id_store.id][key] = val
555 def build_fov_map(t):
556 """Build Thing's FOV map."""
557 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
558 maptype = ctypes.c_char * len(world_db["MAP"])
559 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
560 maptype.from_buffer(t["fovmap"]),
561 maptype.from_buffer(world_db["MAP"]))
563 raise RuntimeError("Malloc error in build_fov_Map().")
566 def decrement_lifepoints(t):
567 """Decrement t's lifepoints by 1, and if to zero, corpse it.
569 If t is the player avatar, only blank its fovmap, so that the client may
570 still display memory data. On non-player things, erase fovmap and memory.
572 t["T_LIFEPOINTS"] -= 1
573 if 0 == t["T_LIFEPOINTS"]:
574 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
575 if world_db["Things"][0] == t:
576 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
577 strong_write(io_db["file_out"], "LOG You die.\n")
580 t["T_MEMMAP"] = False
581 t["T_MEMDEPTHMAP"] = False
583 strong_write(io_db["file_out"], "LOG It dies.\n")
586 def mv_yx_in_dir_legal(dir, y, x):
587 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
588 dir_c = dir.encode("ascii")[0]
589 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
591 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
592 return (test, libpr.result_y(), libpr.result_x())
596 """Make t do nothing (but loudly, if player avatar)."""
597 if t == world_db["Things"][0]:
598 strong_write(io_db["file_out"], "LOG You wait.\n")
602 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
604 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
605 t["T_POSY"], t["T_POSX"])
606 if 1 == move_result[0]:
607 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
608 passable = "." == chr(world_db["MAP"][pos])
609 hitted = [id for id in world_db["Things"]
610 if world_db["Things"][id] != t
611 if world_db["Things"][id]["T_LIFEPOINTS"]
612 if world_db["Things"][id]["T_POSY"] == move_result[1]
613 if world_db["Things"][id]["T_POSX"] == move_result[2]]
616 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
617 hitter = "You" if t == world_db["Things"][0] else hitter_name
618 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
619 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
620 hitted = "you" if hit_id == 0 else hitted_name
621 verb = " wound " if hitter == "You" else " wounds "
622 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
624 decrement_lifepoints(world_db["Things"][hit_id])
626 dir = [dir for dir in directions_db
627 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
629 t["T_POSY"] = move_result[1]
630 t["T_POSX"] = move_result[2]
631 for id in t["T_CARRIES"]:
632 world_db["Things"][id]["T_POSY"] = move_result[1]
633 world_db["Things"][id]["T_POSX"] = move_result[2]
635 if t == world_db["Things"][0]:
636 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
637 elif t == world_db["Things"][0]:
638 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
641 def actor_pick_up(t):
642 """Make t pick up (topmost?) Thing from ground into inventory."""
643 # Topmostness is actually not defined so far. Picks Thing with highest ID.
644 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
645 if not world_db["Things"][id]["carried"]
646 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
647 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
653 world_db["Things"][highest_id]["carried"] = True
654 t["T_CARRIES"].append(highest_id)
655 if t == world_db["Things"][0]:
656 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
657 elif t == world_db["Things"][0]:
658 err = "You try to pick up an object, but there is none."
659 strong_write(io_db["file_out"], "LOG " + err + "\n")
663 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
664 # TODO: Handle case where T_ARGUMENT matches nothing.
665 if len(t["T_CARRIES"]):
666 id = t["T_CARRIES"][t["T_ARGUMENT"]]
667 t["T_CARRIES"].remove(id)
668 world_db["Things"][id]["carried"] = False
669 if t == world_db["Things"][0]:
670 strong_write(io_db["file_out"], "LOG You drop an object.\n")
671 elif t == world_db["Things"][0]:
672 err = "You try to drop an object, but you own none."
673 strong_write(io_db["file_out"], "LOG " + err + "\n")
677 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
678 # TODO: Handle case where T_ARGUMENT matches nothing.
679 if len(t["T_CARRIES"]):
680 id = t["T_CARRIES"][t["T_ARGUMENT"]]
681 type = world_db["Things"][id]["T_TYPE"]
682 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
683 t["T_CARRIES"].remove(id)
684 del world_db["Things"][id]
685 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
686 if t == world_db["Things"][0]:
687 strong_write(io_db["file_out"],
688 "LOG You consume this object.\n")
689 elif t == world_db["Things"][0]:
690 strong_write(io_db["file_out"],
691 "LOG You try to use this object, but fail.\n")
692 elif t == world_db["Things"][0]:
693 strong_write(io_db["file_out"],
694 "LOG You try to use an object, but you own none.\n")
697 def thingproliferation(t):
698 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
700 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
701 passable and not be inhabited by a Thing of the same type, or, if Thing is
702 animate, any other animate Thing. If there are several map cell candidates,
703 one is selected randomly.
705 def test_cell(t, y, x):
706 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
707 for id in [id for id in world_db["Things"]
708 if y == world_db["Things"][id]["T_POSY"]
709 if x == world_db["Things"][id]["T_POSX"]
710 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
711 or (t["T_LIFEPOINTS"] and
712 world_db["Things"][id]["T_LIFEPOINTS"])]:
716 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
717 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
719 for dir in [directions_db[key] for key in directions_db]:
720 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
721 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
722 candidates.append((mv_result[1], mv_result[2]))
724 i = rand.next() % len(candidates)
725 id = id_setter(-1, "Things")
726 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
727 world_db["Things"][id] = newT
731 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
733 On success, decrease satiation score by 32.
735 if t["T_SATIATION"] > 0 \
736 and t["T_LIFEPOINTS"] < \
737 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
738 and 0 == (rand.next() % 31) \
739 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
740 if world_db["ThingActions"][id]["TA_NAME"] ==
742 t["T_LIFEPOINTS"] += 1
743 t["T_SATIATION"] -= 32
744 if t == world_db["Things"][0]:
745 strong_write(io_db["file_out"], "LOG You heal.\n")
747 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
748 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
752 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
753 if t["T_SATIATION"] > -32768:
754 t["T_SATIATION"] -= 1
755 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
756 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
757 raise RuntimeError("A thing that should not hunger is hungering.")
758 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
759 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
760 if t == world_db["Things"][0]:
761 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
763 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
764 strong_write(io_db["file_out"], "LOG " + name +
765 " suffers from hunger.\n")
766 decrement_lifepoints(t)
769 def get_dir_to_target(t, filter):
770 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
772 The path-wise nearest target is chosen, via the shortest available path.
773 Target must not be t. On succcess, return positive value, else False.
775 "a": Thing in FOV is below a certain distance, animate, but of ThingType
776 that is not t's, and starts out weaker than t is; build path as
777 avoiding things of t's ThingType
778 "f": neighbor cell (not inhabited by any animate Thing) further away from
779 animate Thing not further than x steps away and in FOV and of a
780 ThingType that is not t's, and starts out stronger or as strong as t
781 is currently; or (cornered), if no such flight cell, but Thing of
782 above criteria is too near,1 a cell closer to it, or, if less near,
784 "c": Thing in memorized map is consumable
785 "s": memory map cell with greatest-reachable degree of unexploredness
788 def zero_score_map_where_char_on_memdepthmap(c):
789 maptype = ctypes.c_char * len(t["T_MEMDEPTHMAP"])
790 map = maptype.from_buffer(t["T_MEMDEPTHMAP"])
791 test = libpr.zero_score_map_where_char_on_memdepthmap(c, map)
793 raise RuntimeError("No score map allocated for "
794 "zero_score_map_where_char_on_memdepthmap().")
796 def set_map_score(pos, score):
797 test = libpr.set_map_score(pos, score)
799 raise RuntimeError("No score map allocated for set_map_score().")
801 def get_map_score(pos):
802 result = libpr.get_map_score(pos)
804 raise RuntimeError("No score map allocated for get_map_score().")
808 if t["fovmap"] and ("a" == filter or "f" == filter):
809 for id in world_db["Things"]:
810 Thing = world_db["Things"][id]
811 if Thing != t and Thing["T_LIFEPOINTS"] and \
812 t["T_TYPE"] != Thing["T_TYPE"] and \
813 'v' == chr(t["fovmap"][(Thing["T_POSY"]
814 * world_db["MAP_LENGTH"])
816 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
817 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
819 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
822 elif t["T_MEMMAP"] and "c" == filter:
823 for mt in t["T_MEMTHING"]:
824 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
826 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
830 def set_cells_passable_on_memmap_to_65534_on_scoremap():
831 # OUTSOURCED TO libplomrogue.so:
832 # memmap = t["T_MEMMAP"]
833 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
834 # if ord_dot == memmap[i]]:
835 # set_map_score(i, 65534) # i.e. 65535-1
836 map = c_pointer_to_bytearray(t["T_MEMMAP"])
837 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
838 raise RuntimeError("No score map allocated for "
839 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
841 def init_score_map():
842 test = libpr.init_score_map()
844 raise RuntimeError("Malloc error in init_score_map().")
848 set_cells_passable_on_memmap_to_65534_on_scoremap()
850 for id in world_db["Things"]:
851 Thing = world_db["Things"][id]
852 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
854 if t != Thing and Thing["T_LIFEPOINTS"] and \
855 t["T_TYPE"] != Thing["T_TYPE"] and \
856 ord_v == t["fovmap"][pos] and \
857 t["T_LIFEPOINTS"] > \
858 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
859 set_map_score(pos, 0)
860 elif t["T_TYPE"] == Thing["T_TYPE"]:
861 set_map_score(pos, 65535)
863 for id in [id for id in world_db["Things"]
864 if world_db["Things"][id]["T_LIFEPOINTS"]]:
865 Thing = world_db["Things"][id]
866 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
868 if t["T_TYPE"] != Thing["T_TYPE"] and \
869 ord_v == t["fovmap"][pos] and \
870 t["T_LIFEPOINTS"] <= \
871 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
872 set_map_score(pos, 0)
874 for mt in [mt for mt in t["T_MEMTHING"]
875 if ord_blank != t["T_MEMMAP"][mt[1]
876 * world_db["MAP_LENGTH"]
878 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
879 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
881 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
883 def rand_target_dir(neighbors, cmp, dirs):
886 for i in range(len(dirs)):
887 if cmp == neighbors[i]:
888 candidates.append(dirs[i])
890 return candidates[rand.next() % n_candidates] if n_candidates else 0
892 def get_neighbor_scores(dirs, eye_pos):
894 if libpr.ready_neighbor_scores(eye_pos):
895 raise RuntimeError("No score map allocated for " +
896 "ready_neighbor_scores.()")
897 for i in range(len(dirs)):
898 scores.append(libpr.get_neighbor_score(i))
901 def get_dir_from_neighbors():
902 dir_to_target = False
904 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
905 neighbors = get_neighbor_scores(dirs, eye_pos)
907 inhabited = [world_db["Things"][id]["T_POSY"]
908 * world_db["MAP_LENGTH"]
909 + world_db["Things"][id]["T_POSX"]
910 for id in world_db["Things"]
911 if world_db["Things"][id]["T_LIFEPOINTS"]]
912 for i in range(len(dirs)):
913 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
914 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
916 for pos in [pos for pos in inhabited if pos == pos_cmp]:
919 minmax_start = 0 if "f" == filter else 65535 - 1
920 minmax_neighbor = minmax_start
921 for i in range(len(dirs)):
922 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
923 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
924 or ("f" != filter and minmax_neighbor > neighbors[i]):
925 minmax_neighbor = neighbors[i]
926 if minmax_neighbor != minmax_start:
927 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
929 if not dir_to_target:
930 if 1 == get_map_score(eye_pos):
931 dir_to_target = rand_target_dir(neighbors, 0, dirs)
932 elif 3 >= get_map_score(eye_pos):
933 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
935 world_db["ThingActions"][id]["TA_NAME"]
938 elif dir_to_target and 3 < get_map_score(eye_pos):
940 elif "a" == filter and 10 <= get_map_score(eye_pos):
944 dir_to_target = False
946 run_i = 9 + 1 if "s" == filter else 1
947 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
950 mem_depth_c = b'9' if b' ' == mem_depth_c \
951 else bytes([mem_depth_c[0] - 1])
952 if libpr.dijkstra_map():
953 raise RuntimeError("No score map allocated for dijkstra_map().")
954 dir_to_target = get_dir_from_neighbors()
955 libpr.free_score_map()
956 if dir_to_target and str == type(dir_to_target):
957 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
958 if world_db["ThingActions"][id]["TA_NAME"]
960 t["T_ARGUMENT"] = ord(dir_to_target)
964 def standing_on_consumable(t):
965 """Return True/False whether t is standing on a consumable."""
966 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
967 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
968 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
969 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
975 def get_inventory_slot_to_consume(t):
976 """Return slot Id of strongest consumable in t's inventory, else -1."""
977 cmp_consumability = 0
980 for id in t["T_CARRIES"]:
981 type = world_db["Things"][id]["T_TYPE"]
982 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
983 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
990 """Determine next command/argment for actor t via AI algorithms.
992 AI will look for, and move towards, enemies (animate Things not of their
993 own ThingType); if they see none, they will consume consumables in their
994 inventory; if there are none, they will pick up what they stand on if they
995 stand on consumables; if they stand on none, they will move towards the
996 next consumable they see or remember on the map; if they see or remember
997 none, they will explore parts of the map unseen since ever or for at least
998 one turn; if there is nothing to explore, they will simply wait.
1000 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1001 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1002 if not get_dir_to_target(t, "f"):
1003 sel = get_inventory_slot_to_consume(t)
1005 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1006 if world_db["ThingActions"][id]["TA_NAME"]
1008 t["T_ARGUMENT"] = sel
1009 elif standing_on_consumable(t):
1010 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1011 if world_db["ThingActions"][id]["TA_NAME"]
1013 elif (not get_dir_to_target(t, "c")) and \
1014 (not get_dir_to_target(t, "a")):
1015 get_dir_to_target(t, "s")
1019 """Run game world and its inhabitants until new player input expected."""
1021 whilebreaker = False
1022 while world_db["Things"][0]["T_LIFEPOINTS"]:
1023 for id in [id for id in world_db["Things"]]: # Only what's from start!
1024 if not id in world_db["Things"] or \
1025 world_db["Things"][id]["carried"]: # May have been consumed or
1026 continue # picked up during turn …
1027 Thing = world_db["Things"][id]
1028 if Thing["T_LIFEPOINTS"]:
1029 if not Thing["T_COMMAND"]:
1030 update_map_memory(Thing)
1036 Thing["T_PROGRESS"] += 1
1037 taid = [a for a in world_db["ThingActions"]
1038 if a == Thing["T_COMMAND"]][0]
1039 ThingAction = world_db["ThingActions"][taid]
1040 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1041 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1042 Thing["T_COMMAND"] = 0
1043 Thing["T_PROGRESS"] = 0
1045 thingproliferation(Thing)
1048 world_db["TURN"] += 1
1051 def new_Thing(type, pos=(0, 0)):
1052 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1054 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1066 "T_MEMDEPTHMAP": False,
1069 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1070 build_fov_map(thing)
1074 def id_setter(id, category, id_store=False, start_at_1=False):
1075 """Set ID of object of category to manipulate ID unused? Create new one.
1076 The ID is stored as id_store.id (if id_store is set). If the integer of the
1077 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1078 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1079 always returned when no new object is created, else the new object's ID.
1081 min = 0 if start_at_1 else -1
1083 id = integer_test(id, min)
1085 if id in world_db[category]:
1090 if (start_at_1 and 0 == id) \
1091 or ((not start_at_1) and (id < 0)):
1092 id = 0 if start_at_1 else -1
1095 if id not in world_db[category]:
1103 """Send PONG line to server output file."""
1104 strong_write(io_db["file_out"], "PONG\n")
1108 """Abort server process."""
1110 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1111 raise SystemExit("received QUIT command")
1114 def command_thingshere(str_y, str_x):
1115 """Write to out file list of Things known to player at coordinate y, x."""
1116 if world_db["WORLD_ACTIVE"]:
1117 y = integer_test(str_y, 0, 255)
1118 x = integer_test(str_x, 0, 255)
1119 length = world_db["MAP_LENGTH"]
1120 if None != y and None != x and y < length and x < length:
1121 pos = (y * world_db["MAP_LENGTH"]) + x
1122 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1123 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1124 for id in world_db["Things"]:
1125 if y == world_db["Things"][id]["T_POSY"] \
1126 and x == world_db["Things"][id]["T_POSX"] \
1127 and not world_db["Things"][id]["carried"]:
1128 type = world_db["Things"][id]["T_TYPE"]
1129 name = world_db["ThingTypes"][type]["TT_NAME"]
1130 strong_write(io_db["file_out"], name + "\n")
1132 for mt in world_db["Things"][0]["T_MEMTHING"]:
1133 if y == mt[1] and x == mt[2]:
1134 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1135 strong_write(io_db["file_out"], name + "\n")
1136 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1138 print("Ignoring: Invalid map coordinates.")
1140 print("Ignoring: Command only works on existing worlds.")
1143 def play_commander(action, args=False):
1144 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1146 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1150 id = [x for x in world_db["ThingActions"]
1151 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1152 world_db["Things"][0]["T_COMMAND"] = id
1155 def set_command_and_argument_int(str_arg):
1156 val = integer_test(str_arg, 0, 255)
1158 world_db["Things"][0]["T_ARGUMENT"] = val
1161 def set_command_and_argument_movestring(str_arg):
1162 if str_arg in directions_db:
1163 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1166 print("Ignoring: Argument must be valid direction string.")
1168 if action == "move":
1169 return set_command_and_argument_movestring
1171 return set_command_and_argument_int
1176 def command_seedrandomness(seed_string):
1177 """Set rand seed to int(seed_string)."""
1178 val = integer_test(seed_string, 0, 4294967295)
1183 def command_seedmap(seed_string):
1184 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1185 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1189 def command_makeworld(seed_string):
1190 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1192 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1193 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1194 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1195 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1196 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1197 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1198 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1204 err = "Space to put thing on too hard to find. Map too small?"
1206 y = rand.next() % world_db["MAP_LENGTH"]
1207 x = rand.next() % world_db["MAP_LENGTH"]
1208 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1212 raise SystemExit(err)
1213 # Replica of C code, wrongly ignores animatedness of new Thing.
1214 pos_clear = (0 == len([id for id in world_db["Things"]
1215 if world_db["Things"][id]["T_LIFEPOINTS"]
1216 if world_db["Things"][id]["T_POSY"] == y
1217 if world_db["Things"][id]["T_POSX"] == x]))
1222 val = integer_test(seed_string, 0, 4294967295)
1226 world_db["SEED_MAP"] = val
1227 player_will_be_generated = False
1228 playertype = world_db["PLAYER_TYPE"]
1229 for ThingType in world_db["ThingTypes"]:
1230 if playertype == ThingType:
1231 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1232 player_will_be_generated = True
1234 if not player_will_be_generated:
1235 print("Ignoring beyond SEED_MAP: " +
1236 "No player type with start number >0 defined.")
1239 for ThingAction in world_db["ThingActions"]:
1240 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1243 print("Ignoring beyond SEED_MAP: " +
1244 "No thing action with name 'wait' defined.")
1246 world_db["Things"] = {}
1248 world_db["WORLD_ACTIVE"] = 1
1249 world_db["TURN"] = 1
1250 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1251 id = id_setter(-1, "Things")
1252 world_db["Things"][id] = new_Thing(playertype, free_pos())
1253 update_map_memory(world_db["Things"][0])
1254 for type in world_db["ThingTypes"]:
1255 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1256 if type != playertype:
1257 id = id_setter(-1, "Things")
1258 world_db["Things"][id] = new_Thing(type, free_pos())
1259 strong_write(io_db["file_out"], "NEW_WORLD\n")
1262 def command_maplength(maplength_string):
1263 """Redefine map length. Invalidate map, therefore lose all things on it."""
1264 val = integer_test(maplength_string, 1, 256)
1266 world_db["MAP_LENGTH"] = val
1267 set_world_inactive()
1268 world_db["Things"] = {}
1269 libpr.set_maplength(val)
1272 def command_worldactive(worldactive_string):
1273 """Toggle world_db["WORLD_ACTIVE"] if possible.
1275 An active world can always be set inactive. An inactive world can only be
1276 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1277 activation, rebuild all Things' FOVs, and the player's map memory.
1279 # In original version, map existence was also tested (unnecessarily?).
1280 val = integer_test(worldactive_string, 0, 1)
1282 if 0 != world_db["WORLD_ACTIVE"]:
1284 set_world_inactive()
1286 print("World already active.")
1287 elif 0 == world_db["WORLD_ACTIVE"]:
1289 for ThingAction in world_db["ThingActions"]:
1290 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1293 player_exists = False
1294 for Thing in world_db["Things"]:
1296 player_exists = True
1298 if wait_exists and player_exists:
1299 for id in world_db["Things"]:
1300 if world_db["Things"][id]["T_LIFEPOINTS"]:
1301 build_fov_map(world_db["Things"][id])
1303 update_map_memory(world_db["Things"][id], False)
1304 world_db["WORLD_ACTIVE"] = 1
1307 def test_for_id_maker(object, category):
1308 """Return decorator testing for object having "id" attribute."""
1311 if hasattr(object, "id"):
1314 print("Ignoring: No " + category +
1315 " defined to manipulate yet.")
1320 def command_tid(id_string):
1321 """Set ID of Thing to manipulate. ID unused? Create new one.
1323 Default new Thing's type to the first available ThingType, others: zero.
1325 id = id_setter(id_string, "Things", command_tid)
1327 if world_db["ThingTypes"] == {}:
1328 print("Ignoring: No ThingType to settle new Thing in.")
1330 type = list(world_db["ThingTypes"].keys())[0]
1331 world_db["Things"][id] = new_Thing(type)
1334 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1338 def command_tcommand(str_int):
1339 """Set T_COMMAND of selected Thing."""
1340 val = integer_test(str_int, 0)
1342 if 0 == val or val in world_db["ThingActions"]:
1343 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1345 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1349 def command_ttype(str_int):
1350 """Set T_TYPE of selected Thing."""
1351 val = integer_test(str_int, 0)
1353 if val in world_db["ThingTypes"]:
1354 world_db["Things"][command_tid.id]["T_TYPE"] = val
1356 print("Ignoring: ThingType ID belongs to no known ThingType.")
1360 def command_tcarries(str_int):
1361 """Append int(str_int) to T_CARRIES of selected Thing.
1363 The ID int(str_int) must not be of the selected Thing, and must belong to a
1364 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1366 val = integer_test(str_int, 0)
1368 if val == command_tid.id:
1369 print("Ignoring: Thing cannot carry itself.")
1370 elif val in world_db["Things"] \
1371 and not world_db["Things"][val]["carried"]:
1372 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1373 world_db["Things"][val]["carried"] = True
1375 print("Ignoring: Thing not available for carrying.")
1376 # Note that the whole carrying structure is different from the C version:
1377 # Carried-ness is marked by a "carried" flag, not by Things containing
1378 # Things internally.
1382 def command_tmemthing(str_t, str_y, str_x):
1383 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1385 The type must fit to an existing ThingType, and the position into the map.
1387 type = integer_test(str_t, 0)
1388 posy = integer_test(str_y, 0, 255)
1389 posx = integer_test(str_x, 0, 255)
1390 if None != type and None != posy and None != posx:
1391 if type not in world_db["ThingTypes"] \
1392 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1393 print("Ignoring: Illegal value for thing type or position.")
1395 memthing = (type, posy, posx)
1396 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1399 def setter_map(maptype):
1400 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1402 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1405 def helper(str_int, mapline):
1406 val = integer_test(str_int, 0, 255)
1408 if val >= world_db["MAP_LENGTH"]:
1409 print("Illegal value for map line number.")
1410 elif len(mapline) != world_db["MAP_LENGTH"]:
1411 print("Map line length is unequal map width.")
1413 length = world_db["MAP_LENGTH"]
1415 if not world_db["Things"][command_tid.id][maptype]:
1416 map = bytearray(b' ' * (length ** 2))
1418 map = world_db["Things"][command_tid.id][maptype]
1419 map[val * length:(val * length) + length] = mapline.encode()
1420 world_db["Things"][command_tid.id][maptype] = map
1424 def setter_tpos(axis):
1425 """Generate setter for T_POSX or T_POSY of selected Thing.
1427 If world is active, rebuilds animate things' fovmap, player's memory map.
1430 def helper(str_int):
1431 val = integer_test(str_int, 0, 255)
1433 if val < world_db["MAP_LENGTH"]:
1434 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1435 if world_db["WORLD_ACTIVE"] \
1436 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1437 build_fov_map(world_db["Things"][command_tid.id])
1438 if 0 == command_tid.id:
1439 update_map_memory(world_db["Things"][command_tid.id])
1441 print("Ignoring: Position is outside of map.")
1445 def command_ttid(id_string):
1446 """Set ID of ThingType to manipulate. ID unused? Create new one.
1448 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1450 id = id_setter(id_string, "ThingTypes", command_ttid)
1452 world_db["ThingTypes"][id] = {
1453 "TT_NAME": "(none)",
1456 "TT_PROLIFERATE": 0,
1457 "TT_START_NUMBER": 0,
1463 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1467 def command_ttname(name):
1468 """Set TT_NAME of selected ThingType."""
1469 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1473 def command_ttsymbol(char):
1474 """Set TT_SYMBOL of selected ThingType. """
1476 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1478 print("Ignoring: Argument must be single character.")
1482 def command_ttcorpseid(str_int):
1483 """Set TT_CORPSE_ID of selected ThingType."""
1484 val = integer_test(str_int, 0)
1486 if val in world_db["ThingTypes"]:
1487 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1489 print("Ignoring: Corpse ID belongs to no known ThignType.")
1492 def command_taid(id_string):
1493 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1495 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1497 id = id_setter(id_string, "ThingActions", command_taid, True)
1499 world_db["ThingActions"][id] = {
1505 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1508 @test_ThingAction_id
1509 def command_taname(name):
1510 """Set TA_NAME of selected ThingAction.
1512 The name must match a valid thing action function. If after the name
1513 setting no ThingAction with name "wait" remains, call set_world_inactive().
1515 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1516 or name == "pick_up":
1517 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1518 if 1 == world_db["WORLD_ACTIVE"]:
1519 wait_defined = False
1520 for id in world_db["ThingActions"]:
1521 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1524 if not wait_defined:
1525 set_world_inactive()
1527 print("Ignoring: Invalid action name.")
1528 # In contrast to the original,naming won't map a function to a ThingAction.
1532 """Call ai() on player Thing, then turn_over()."""
1533 ai(world_db["Things"][0])
1537 """Commands database.
1539 Map command start tokens to ([0]) number of expected command arguments, ([1])
1540 the command's meta-ness (i.e. is it to be written to the record file, is it to
1541 be ignored in replay mode if read from server input file), and ([2]) a function
1545 "QUIT": (0, True, command_quit),
1546 "PING": (0, True, command_ping),
1547 "THINGS_HERE": (2, True, command_thingshere),
1548 "MAKE_WORLD": (1, False, command_makeworld),
1549 "SEED_MAP": (1, False, command_seedmap),
1550 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1551 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1552 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1553 "MAP_LENGTH": (1, False, command_maplength),
1554 "WORLD_ACTIVE": (1, False, command_worldactive),
1555 "TA_ID": (1, False, command_taid),
1556 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1557 "TA_NAME": (1, False, command_taname),
1558 "TT_ID": (1, False, command_ttid),
1559 "TT_NAME": (1, False, command_ttname),
1560 "TT_SYMBOL": (1, False, command_ttsymbol),
1561 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1562 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1564 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1566 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1568 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1569 "T_ID": (1, False, command_tid),
1570 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1571 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1572 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1573 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1574 "T_COMMAND": (1, False, command_tcommand),
1575 "T_TYPE": (1, False, command_ttype),
1576 "T_CARRIES": (1, False, command_tcarries),
1577 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1578 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1579 "T_MEMTHING": (3, False, command_tmemthing),
1580 "T_POSY": (1, False, setter_tpos("Y")),
1581 "T_POSX": (1, False, setter_tpos("X")),
1582 "wait": (0, False, play_commander("wait")),
1583 "move": (1, False, play_commander("move")),
1584 "pick_up": (0, False, play_commander("pick_up")),
1585 "drop": (1, False, play_commander("drop", True)),
1586 "use": (1, False, play_commander("use", True)),
1587 "ai": (0, False, command_ai)
1591 """World state database. With sane default values. (Randomness is in rand.)"""
1603 """Mapping of direction names to internal direction chars."""
1604 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1605 "west": "s", "north-west": "w", "north-east": "e"}
1607 """File IO database."""
1609 "path_save": "save",
1610 "path_record": "record_save",
1611 "path_worldconf": "confserver/world",
1612 "path_server": "server/",
1613 "path_in": "server/in",
1614 "path_out": "server/out",
1615 "path_worldstate": "server/worldstate",
1616 "tmp_suffix": "_tmp",
1617 "kicked_by_rival": False,
1618 "worldstate_updateable": False
1623 libpr = prep_library()
1624 rand = RandomnessIO()
1625 opts = parse_command_line_arguments()
1627 io_db["path_save"] = opts.savefile
1628 io_db["path_record"] = "record_" + opts.savefile
1631 io_db["verbose"] = True
1632 if None != opts.replay:
1636 except SystemExit as exit:
1637 print("ABORTING: " + exit.args[0])
1639 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")