11 """"Interface to libplomrogue's pseudo-randomness generator."""
13 def set_seed(self, seed):
14 libpr.seed_rrand(1, seed)
17 return libpr.seed_rrand(0, 0)
22 seed = property(get_seed, set_seed)
26 """Prepare ctypes library at ./libplomrogue.so"""
27 libpath = ("./libplomrogue.so")
28 if not os.access(libpath, os.F_OK):
29 raise SystemExit("No library " + libpath + ", run ./compile.sh first?")
30 libpr = ctypes.cdll.LoadLibrary(libpath)
31 libpr.seed_rrand.argtypes = [ctypes.c_uint8, ctypes.c_uint32]
32 libpr.seed_rrand.restype = ctypes.c_uint32
33 libpr.rrand.argtypes = []
34 libpr.rrand.restype = ctypes.c_uint16
35 libpr.set_maplength.argtypes = [ctypes.c_uint16]
36 libpr.mv_yx_in_dir_legal_wrap.argtypes = [ctypes.c_char, ctypes.c_uint8,
38 libpr.mv_yx_in_dir_legal_wrap.restype = ctypes.c_uint8
39 libpr.result_y.restype = ctypes.c_uint8
40 libpr.result_x.restype = ctypes.c_uint8
41 libpr.set_maplength(world_db["MAP_LENGTH"])
42 libpr.build_fov_map.argtypes = [ctypes.c_uint8, ctypes.c_uint8,
43 ctypes.c_char_p, ctypes.c_char_p]
44 libpr.build_fov_map.restype = ctypes.c_uint8
45 libpr.init_score_map.restype = ctypes.c_uint8
46 libpr.set_map_score.argtypes = [ctypes.c_uint16, ctypes.c_uint16]
47 libpr.set_map_score.restype = ctypes.c_uint8
48 libpr.get_map_score.argtypes = [ctypes.c_uint16]
49 libpr.get_map_score.restype = ctypes.c_int32
50 libpr.get_neighbor_score.argtypes = [ctypes.c_uint8]
51 libpr.get_neighbor_score.restype = ctypes.c_uint16
52 libpr.ready_neighbor_scores.argtpes = [ctypes.c_uint16]
53 libpr.ready_neighbor_scores.restype = ctypes.c_uint8
54 libpr.dijkstra_map.restype = ctypes.c_uint8
58 def strong_write(file, string):
59 """Apply write(string), then flush()."""
64 def setup_server_io():
65 """Fill IO files DB with proper file( path)s. Write process IO test string.
67 Ensure IO files directory at server/. Remove any old input file if found.
68 Set up new input file for reading, and new output file for writing. Start
69 output file with process hash line of format PID + " " + floated UNIX time
70 (io_db["teststring"]). Raise SystemExit if file is found at path of either
71 record or save file plus io_db["tmp_suffix"].
73 def detect_atomic_leftover(path, tmp_suffix):
74 path_tmp = path + tmp_suffix
75 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
76 "aborted previous attempt to write '" + path + "'. Aborting " \
77 "until matter is resolved by removing it from its current path."
78 if os.access(path_tmp, os.F_OK):
80 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
81 io_db["save_wait"] = 0
82 io_db["verbose"] = False
83 io_db["record_chunk"] = ""
84 os.makedirs(io_db["path_server"], exist_ok=True)
85 io_db["file_out"] = open(io_db["path_out"], "w")
86 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
87 if os.access(io_db["path_in"], os.F_OK):
88 os.remove(io_db["path_in"])
89 io_db["file_in"] = open(io_db["path_in"], "w")
90 io_db["file_in"].close()
91 io_db["file_in"] = open(io_db["path_in"], "r")
92 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
93 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
96 def cleanup_server_io():
97 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
98 def helper(file_key, path_key):
100 io_db[file_key].close()
101 if not io_db["kicked_by_rival"] \
102 and os.access(io_db[path_key], os.F_OK):
103 os.remove(io_db[path_key])
104 helper("file_in", "path_in")
105 helper("file_out", "path_out")
106 helper("file_worldstate", "path_worldstate")
107 if "file_record" in io_db:
108 io_db["file_record"].close()
111 def obey(command, prefix, replay=False, do_record=False):
112 """Call function from commands_db mapped to command's first token.
114 Tokenize command string with shlex.split(comments=True). If replay is set,
115 a non-meta command from the commands_db merely triggers obey() on the next
116 command from the records file. If not, non-meta commands set
117 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
118 do_record is set, are recorded to io_db["record_chunk"], and save_world()
119 is called (and io_db["record_chunk"] written) if 15 seconds have passed
120 since the last time it was called. The prefix string is inserted into the
121 server's input message between its beginning 'input ' and ':'. All activity
122 is preceded by a server_test() call.
126 print("input " + prefix + ": " + command)
128 tokens = shlex.split(command, comments=True)
129 except ValueError as err:
130 print("Can't tokenize command string: " + str(err) + ".")
132 if len(tokens) > 0 and tokens[0] in commands_db \
133 and len(tokens) == commands_db[tokens[0]][0] + 1:
134 if commands_db[tokens[0]][1]:
135 commands_db[tokens[0]][2](*tokens[1:])
137 print("Due to replay mode, reading command as 'go on in record'.")
138 line = io_db["file_record"].readline()
140 obey(line.rstrip(), io_db["file_record"].prefix
141 + str(io_db["file_record"].line_n))
142 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
144 print("Reached end of record file.")
146 commands_db[tokens[0]][2](*tokens[1:])
148 io_db["record_chunk"] += command + "\n"
149 if time.time() > io_db["save_wait"] + 15:
150 atomic_write(io_db["path_record"], io_db["record_chunk"],
153 io_db["record_chunk"] = ""
154 io_db["save_wait"] = time.time()
155 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
156 elif 0 != len(tokens):
157 print("Invalid command/argument, or bad number of tokens.")
160 def atomic_write(path, text, do_append=False):
161 """Atomic write of text to file at path, appended if do_append is set."""
162 path_tmp = path + io_db["tmp_suffix"]
166 if os.access(path, os.F_OK):
167 shutil.copyfile(path, path_tmp)
168 file = open(path_tmp, mode)
169 strong_write(file, text)
171 if os.access(path, os.F_OK):
173 os.rename(path_tmp, path)
177 """Save all commands needed to reconstruct current world state."""
180 string = string.replace("\u005C", '\u005C\u005C')
181 return '"' + string.replace('"', '\u005C"') + '"'
186 if world_db["Things"][id][key]:
187 map = world_db["Things"][id][key]
188 length = world_db["MAP_LENGTH"]
189 for i in range(length):
190 line = map[i * length:(i * length) + length].decode()
191 string = string + key + " " + str(i) + " " + quote(line) \
198 for memthing in world_db["Things"][id]["T_MEMTHING"]:
199 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
200 str(memthing[1]) + " " + str(memthing[2]) + "\n"
203 def helper(category, id_string, special_keys={}):
205 for id in world_db[category]:
206 string = string + id_string + " " + str(id) + "\n"
207 for key in world_db[category][id]:
208 if not key in special_keys:
209 x = world_db[category][id][key]
210 argument = quote(x) if str == type(x) else str(x)
211 string = string + key + " " + argument + "\n"
212 elif special_keys[key]:
213 string = string + special_keys[key](id)
218 if dict != type(world_db[key]) and key != "MAP" and \
219 key != "WORLD_ACTIVE" and key != "SEED_MAP":
220 string = string + key + " " + str(world_db[key]) + "\n"
221 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
222 string = string + helper("ThingActions", "TA_ID")
223 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
224 for id in world_db["ThingTypes"]:
225 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
226 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
227 string = string + helper("Things", "T_ID",
228 {"T_CARRIES": False, "carried": False,
229 "T_MEMMAP": mapsetter("T_MEMMAP"),
230 "T_MEMTHING": memthing, "fovmap": False,
231 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
232 for id in world_db["Things"]:
233 if [] != world_db["Things"][id]["T_CARRIES"]:
234 string = string + "T_ID " + str(id) + "\n"
235 for carried_id in world_db["Things"][id]["T_CARRIES"]:
236 string = string + "T_CARRIES " + str(carried_id) + "\n"
237 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
238 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
239 atomic_write(io_db["path_save"], string)
242 def obey_lines_in_file(path, name, do_record=False):
243 """Call obey() on each line of path's file, use name in input prefix."""
244 file = open(path, "r")
246 for line in file.readlines():
247 obey(line.rstrip(), name + "file line " + str(line_n),
253 def parse_command_line_arguments():
254 """Return settings values read from command line arguments."""
255 parser = argparse.ArgumentParser()
256 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
258 parser.add_argument('-v', dest='verbose', action='store_true')
259 opts, unknown = parser.parse_known_args()
264 """Ensure valid server out file belonging to current process.
266 This is done by comparing io_db["teststring"] to what's found at the start
267 of the current file at io_db["path_out"]. On failure, set
268 io_db["kicked_by_rival"] and raise SystemExit.
270 if not os.access(io_db["path_out"], os.F_OK):
271 raise SystemExit("Server output file has disappeared.")
272 file = open(io_db["path_out"], "r")
273 test = file.readline().rstrip("\n")
275 if test != io_db["teststring"]:
276 io_db["kicked_by_rival"] = True
277 msg = "Server test string in server output file does not match. This" \
278 " indicates that the current server process has been " \
279 "superseded by another one."
280 raise SystemExit(msg)
284 """Return next newline-delimited command from server in file.
286 Keep building return string until a newline is encountered. Pause between
287 unsuccessful reads, and after too much waiting, run server_test().
289 wait_on_fail = 0.03333
294 add = io_db["file_in"].readline()
296 command = command + add
297 if len(command) > 0 and "\n" == command[-1]:
298 command = command[:-1]
301 time.sleep(wait_on_fail)
302 if now + max_wait < time.time():
308 def try_worldstate_update():
309 """Write worldstate file if io_db["worldstate_updateable"] is set."""
310 if io_db["worldstate_updateable"]:
312 def draw_visible_Things(map, run):
313 for id in world_db["Things"]:
314 type = world_db["Things"][id]["T_TYPE"]
315 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
316 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
317 if (0 == run and not consumable and not alive) \
318 or (1 == run and consumable and not alive) \
319 or (2 == run and alive):
320 y = world_db["Things"][id]["T_POSY"]
321 x = world_db["Things"][id]["T_POSX"]
322 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
323 if 'v' == chr(fovflag):
324 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
325 map[(y * length) + x] = ord(c)
327 def write_map(string, map):
328 for i in range(length):
329 line = map[i * length:(i * length) + length].decode()
330 string = string + line + "\n"
334 if [] == world_db["Things"][0]["T_CARRIES"]:
335 inventory = "(none)\n"
337 for id in world_db["Things"][0]["T_CARRIES"]:
338 type_id = world_db["Things"][id]["T_TYPE"]
339 name = world_db["ThingTypes"][type_id]["TT_NAME"]
340 inventory = inventory + name + "\n"
341 string = str(world_db["TURN"]) + "\n" + \
342 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
343 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
344 inventory + "%\n" + \
345 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
346 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
347 str(world_db["MAP_LENGTH"]) + "\n"
348 length = world_db["MAP_LENGTH"]
349 fov = bytearray(b' ' * (length ** 2))
350 for pos in range(length ** 2):
351 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
352 fov[pos] = world_db["MAP"][pos]
354 draw_visible_Things(fov, i)
355 string = write_map(string, fov)
356 mem = world_db["Things"][0]["T_MEMMAP"][:]
358 for mt in world_db["Things"][0]["T_MEMTHING"]:
359 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
360 if (i == 0 and not consumable) or (i == 1 and consumable):
361 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
362 mem[(mt[1] * length) + mt[2]] = ord(c)
363 string = write_map(string, mem)
364 atomic_write(io_db["path_worldstate"], string)
365 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
366 io_db["worldstate_updateable"] = False
370 """Replay game from record file.
372 Use opts.replay as breakpoint turn to which to replay automatically before
373 switching to manual input by non-meta commands in server input file
374 triggering further reads of record file. Ensure opts.replay is at least 1.
375 Run try_worldstate_update() before each interactive obey()/read_command().
379 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
380 " (if so late a turn is to be found).")
381 if not os.access(io_db["path_record"], os.F_OK):
382 raise SystemExit("No record file found to replay.")
383 io_db["file_record"] = open(io_db["path_record"], "r")
384 io_db["file_record"].prefix = "record file line "
385 io_db["file_record"].line_n = 1
386 while world_db["TURN"] < opts.replay:
387 line = io_db["file_record"].readline()
390 obey(line.rstrip(), io_db["file_record"].prefix
391 + str(io_db["file_record"].line_n))
392 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
394 try_worldstate_update()
395 obey(read_command(), "in file", replay=True)
399 """Play game by server input file commands. Before, load save file found.
401 If no save file is found, a new world is generated from the commands in the
402 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
403 command and all that follow via the server input file. Run
404 try_worldstate_update() before each interactive obey()/read_command().
406 if os.access(io_db["path_save"], os.F_OK):
407 obey_lines_in_file(io_db["path_save"], "save")
409 if not os.access(io_db["path_worldconf"], os.F_OK):
410 msg = "No world config file from which to start a new world."
411 raise SystemExit(msg)
412 obey_lines_in_file(io_db["path_worldconf"], "world config ",
414 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
416 try_worldstate_update()
417 obey(read_command(), "in file", do_record=True)
421 """(Re-)make island map.
423 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
424 start with one land cell in the middle, then go into cycle of repeatedly
425 selecting a random sea cell and transforming it into land if it is neighbor
426 to land. The cycle ends when a land cell is due to be created at the map's
427 border. Then put some trees on the map (TODO: more precise algorithm desc).
429 def is_neighbor(coordinates, type):
432 length = world_db["MAP_LENGTH"]
434 diag_west = x + (ind > 0)
435 diag_east = x + (ind < (length - 1))
436 pos = (y * length) + x
437 if (y > 0 and diag_east
438 and type == chr(world_db["MAP"][pos - length + ind])) \
440 and type == chr(world_db["MAP"][pos + 1])) \
441 or (y < (length - 1) and diag_east
442 and type == chr(world_db["MAP"][pos + length + ind])) \
443 or (y > 0 and diag_west
444 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
446 and type == chr(world_db["MAP"][pos - 1])) \
447 or (y < (length - 1) and diag_west
448 and type == chr(world_db["MAP"][pos + length - (not ind)])):
451 store_seed = rand.seed
452 rand.seed = world_db["SEED_MAP"]
453 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
454 length = world_db["MAP_LENGTH"]
455 add_half_width = (not (length % 2)) * int(length / 2)
456 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
458 y = rand.next() % length
459 x = rand.next() % length
460 pos = (y * length) + x
461 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
462 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
464 world_db["MAP"][pos] = ord(".")
465 n_trees = int((length ** 2) / 16)
467 while (i_trees <= n_trees):
468 single_allowed = rand.next() % 32
469 y = rand.next() % length
470 x = rand.next() % length
471 pos = (y * length) + x
472 if "." == chr(world_db["MAP"][pos]) \
473 and ((not single_allowed) or is_neighbor((y, x), "X")):
474 world_db["MAP"][pos] = ord("X")
476 rand.seed = store_seed
477 # This all-too-precise replica of the original C code misses iter_limit().
480 def update_map_memory(t, age_map=True):
481 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
482 if not t["T_MEMMAP"]:
483 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
484 if not t["T_MEMDEPTHMAP"]:
485 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
486 for pos in range(world_db["MAP_LENGTH"] ** 2):
487 if "v" == chr(t["fovmap"][pos]):
488 t["T_MEMDEPTHMAP"][pos] = ord("0")
489 if " " == chr(t["T_MEMMAP"][pos]):
490 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
492 if age_map and ord('0') <= t["T_MEMDEPTHMAP"][pos] \
493 and ord('9') > t["T_MEMDEPTHMAP"][pos] \
494 and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)):
495 t["T_MEMDEPTHMAP"][pos] += 1
496 for mt in [mt for mt in t["T_MEMTHING"]
497 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
499 t["T_MEMTHING"].remove(mt)
500 for id in [id for id in world_db["Things"]
501 if not world_db["Things"][id]["carried"]]:
502 type = world_db["Things"][id]["T_TYPE"]
503 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
504 y = world_db["Things"][id]["T_POSY"]
505 x = world_db["Things"][id]["T_POSX"]
506 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
507 t["T_MEMTHING"].append((type, y, x))
510 def set_world_inactive():
511 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
513 if os.access(io_db["path_worldstate"], os.F_OK):
514 os.remove(io_db["path_worldstate"])
515 world_db["WORLD_ACTIVE"] = 0
518 def integer_test(val_string, min, max):
519 """Return val_string if possible integer >= min and <= max, else None."""
521 val = int(val_string)
522 if val < min or val > max:
526 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
531 def setter(category, key, min, max):
532 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
535 val = integer_test(val_string, min, max)
539 if category == "Thing":
540 id_store = command_tid
541 decorator = test_Thing_id
542 elif category == "ThingType":
543 id_store = command_ttid
544 decorator = test_ThingType_id
545 elif category == "ThingAction":
546 id_store = command_taid
547 decorator = test_ThingAction_id
551 val = integer_test(val_string, min, max)
553 world_db[category + "s"][id_store.id][key] = val
557 def build_fov_map(t):
558 """Build Thing's FOV map."""
559 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
560 maptype = ctypes.c_char * len(world_db["MAP"])
561 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
562 maptype.from_buffer(t["fovmap"]),
563 maptype.from_buffer(world_db["MAP"]))
565 raise RuntimeError("Malloc error in build_fov_Map().")
568 def decrement_lifepoints(t):
569 """Decrement t's lifepoints by 1, and if to zero, corpse it.
571 If t is the player avatar, only blank its fovmap, so that the client may
572 still display memory data. On non-player things, erase fovmap and memory.
574 t["T_LIFEPOINTS"] -= 1
575 if 0 == t["T_LIFEPOINTS"]:
576 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
577 if world_db["Things"][0] == t:
578 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
579 strong_write(io_db["file_out"], "LOG You die.\n")
582 t["T_MEMMAP"] = False
583 t["T_MEMDEPTHMAP"] = False
585 strong_write(io_db["file_out"], "LOG It dies.\n")
588 def mv_yx_in_dir_legal(dir, y, x):
589 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
590 dir_c = dir.encode("ascii")[0]
591 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
593 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
594 return (test, libpr.result_y(), libpr.result_x())
598 """Make t do nothing (but loudly, if player avatar)."""
599 if t == world_db["Things"][0]:
600 strong_write(io_db["file_out"], "LOG You wait.\n")
604 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
606 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
607 t["T_POSY"], t["T_POSX"])
608 if 1 == move_result[0]:
609 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
610 passable = "." == chr(world_db["MAP"][pos])
611 hitted = [id for id in world_db["Things"]
612 if world_db["Things"][id] != t
613 if world_db["Things"][id]["T_LIFEPOINTS"]
614 if world_db["Things"][id]["T_POSY"] == move_result[1]
615 if world_db["Things"][id]["T_POSX"] == move_result[2]]
618 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
619 hitter = "You" if t == world_db["Things"][0] else hitter_name
620 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
621 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
622 hitted = "you" if hit_id == 0 else hitted_name
623 verb = " wound " if hitter == "You" else " wounds "
624 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
626 decrement_lifepoints(world_db["Things"][hit_id])
628 dir = [dir for dir in directions_db
629 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
631 t["T_POSY"] = move_result[1]
632 t["T_POSX"] = move_result[2]
633 for id in t["T_CARRIES"]:
634 world_db["Things"][id]["T_POSY"] = move_result[1]
635 world_db["Things"][id]["T_POSX"] = move_result[2]
637 if t == world_db["Things"][0]:
638 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
639 elif t == world_db["Things"][0]:
640 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
643 def actor_pick_up(t):
644 """Make t pick up (topmost?) Thing from ground into inventory."""
645 # Topmostness is actually not defined so far. Picks Thing with highest ID.
646 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
647 if not world_db["Things"][id]["carried"]
648 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
649 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
655 world_db["Things"][highest_id]["carried"] = True
656 t["T_CARRIES"].append(highest_id)
657 if t == world_db["Things"][0]:
658 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
659 elif t == world_db["Things"][0]:
660 err = "You try to pick up an object, but there is none."
661 strong_write(io_db["file_out"], "LOG " + err + "\n")
665 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
666 # TODO: Handle case where T_ARGUMENT matches nothing.
667 if len(t["T_CARRIES"]):
668 id = t["T_CARRIES"][t["T_ARGUMENT"]]
669 t["T_CARRIES"].remove(id)
670 world_db["Things"][id]["carried"] = False
671 if t == world_db["Things"][0]:
672 strong_write(io_db["file_out"], "LOG You drop an object.\n")
673 elif t == world_db["Things"][0]:
674 err = "You try to drop an object, but you own none."
675 strong_write(io_db["file_out"], "LOG " + err + "\n")
679 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
680 # TODO: Handle case where T_ARGUMENT matches nothing.
681 if len(t["T_CARRIES"]):
682 id = t["T_CARRIES"][t["T_ARGUMENT"]]
683 type = world_db["Things"][id]["T_TYPE"]
684 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
685 t["T_CARRIES"].remove(id)
686 del world_db["Things"][id]
687 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
688 if t == world_db["Things"][0]:
689 strong_write(io_db["file_out"],
690 "LOG You consume this object.\n")
691 elif t == world_db["Things"][0]:
692 strong_write(io_db["file_out"],
693 "LOG You try to use this object, but fail.\n")
694 elif t == world_db["Things"][0]:
695 strong_write(io_db["file_out"],
696 "LOG You try to use an object, but you own none.\n")
699 def thingproliferation(t):
700 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
702 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
703 passable and not be inhabited by a Thing of the same type, or, if Thing is
704 animate, any other animate Thing. If there are several map cell candidates,
705 one is selected randomly.
707 def test_cell(t, y, x):
708 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
709 for id in [id for id in world_db["Things"]
710 if y == world_db["Things"][id]["T_POSY"]
711 if x == world_db["Things"][id]["T_POSX"]
712 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
713 or (t["T_LIFEPOINTS"] and
714 world_db["Things"][id]["T_LIFEPOINTS"])]:
718 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
719 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
721 for dir in [directions_db[key] for key in directions_db]:
722 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
723 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
724 candidates.append((mv_result[1], mv_result[2]))
726 i = rand.next() % len(candidates)
727 id = id_setter(-1, "Things")
728 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
729 world_db["Things"][id] = newT
733 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
735 On success, decrease satiation score by 32.
737 if t["T_SATIATION"] > 0 \
738 and t["T_LIFEPOINTS"] < \
739 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
740 and 0 == (rand.next() % 31) \
741 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
742 if world_db["ThingActions"][id]["TA_NAME"] ==
744 t["T_LIFEPOINTS"] += 1
745 t["T_SATIATION"] -= 32
746 if t == world_db["Things"][0]:
747 strong_write(io_db["file_out"], "LOG You heal.\n")
749 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
750 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
754 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
755 if t["T_SATIATION"] > -32768:
756 t["T_SATIATION"] -= 1
757 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
758 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
759 raise RuntimeError("A thing that should not hunger is hungering.")
760 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
761 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
762 if t == world_db["Things"][0]:
763 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
765 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
766 strong_write(io_db["file_out"], "LOG " + name +
767 " suffers from hunger.\n")
768 decrement_lifepoints(t)
771 def get_dir_to_target(t, filter):
772 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
774 The path-wise nearest target is chosen, via the shortest available path.
775 Target must not be t. On succcess, return positive value, else False.
777 "a": Thing in FOV is below a certain distance, animate, but of ThingType
778 that is not t's, and starts out weaker than t is; build path as
779 avoiding things of t's ThingType
780 "f": neighbor cell (not inhabited by any animate Thing) further away from
781 animate Thing not further than x steps away and in FOV and of a
782 ThingType that is not t's, and starts out stronger or as strong as t
783 is currently; or (cornered), if no such flight cell, but Thing of
784 above criteria is too near,1 a cell closer to it, or, if less near,
786 "c": Thing in memorized map is consumable
787 "s": memory map cell with greatest-reachable degree of unexploredness
790 def set_map_score(pos, score):
791 test = libpr.set_map_score(pos, score)
793 raise RuntimeError("No score map allocated for set_map_score().")
795 def get_map_score(pos):
796 result = libpr.get_map_score(pos)
798 raise RuntimeError("No score map allocated for get_map_score().")
802 if t["fovmap"] and ("a" == filter or "f" == filter):
803 for id in world_db["Things"]:
804 Thing = world_db["Things"][id]
805 if Thing != t and Thing["T_LIFEPOINTS"] and \
806 t["T_TYPE"] != Thing["T_TYPE"] and \
807 'v' == chr(t["fovmap"][(Thing["T_POSY"]
808 * world_db["MAP_LENGTH"])
810 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
811 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
813 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
816 elif t["T_MEMMAP"] and "c" == filter:
817 for mt in t["T_MEMTHING"]:
818 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
820 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
824 def init_score_map():
825 test = libpr.init_score_map()
827 raise RuntimeError("Malloc error in init_score_map().")
828 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
829 if '.' == chr(t["T_MEMMAP"][i])]:
830 set_map_score(i, 65535 - 1)
832 for id in world_db["Things"]:
833 Thing = world_db["Things"][id]
834 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
836 if t != Thing and Thing["T_LIFEPOINTS"] and \
837 t["T_TYPE"] != Thing["T_TYPE"] and \
838 'v' == chr(t["fovmap"][pos]) and \
839 t["T_LIFEPOINTS"] > \
840 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
841 set_map_score(pos, 0)
842 elif t["T_TYPE"] == Thing["T_TYPE"]:
843 set_map_score(pos, 65535)
845 for id in [id for id in world_db["Things"]
846 if world_db["Things"][id]["T_LIFEPOINTS"]]:
847 Thing = world_db["Things"][id]
848 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
850 if t["T_TYPE"] != Thing["T_TYPE"] and \
851 'v' == chr(t["fovmap"][pos]) and \
852 t["T_LIFEPOINTS"] <= \
853 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
854 set_map_score(pos, 0)
856 for mt in [mt for mt in t["T_MEMTHING"]
857 if ' ' != chr(t["T_MEMMAP"][mt[1]
858 * world_db["MAP_LENGTH"]
860 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
861 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
863 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
864 if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
867 def rand_target_dir(neighbors, cmp, dirs):
870 for i in range(len(dirs)):
871 if cmp == neighbors[i]:
872 candidates.append(dirs[i])
874 return candidates[rand.next() % n_candidates] if n_candidates else 0
876 def get_neighbor_scores(dirs, eye_pos):
878 if libpr.ready_neighbor_scores(eye_pos):
879 raise RuntimeError("No score map allocated for " +
880 "ready_neighbor_scores.()")
881 for i in range(len(dirs)):
882 scores.append(libpr.get_neighbor_score(i))
885 def get_dir_from_neighbors():
886 dir_to_target = False
888 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
889 neighbors = get_neighbor_scores(dirs, eye_pos)
891 inhabited = [world_db["Things"][id]["T_POSY"]
892 * world_db["MAP_LENGTH"]
893 + world_db["Things"][id]["T_POSX"]
894 for id in world_db["Things"]
895 if world_db["Things"][id]["T_LIFEPOINTS"]]
896 for i in range(len(dirs)):
897 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
898 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
900 for pos in [pos for pos in inhabited if pos == pos_cmp]:
903 minmax_start = 0 if "f" == filter else 65535 - 1
904 minmax_neighbor = minmax_start
905 for i in range(len(dirs)):
906 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
907 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
908 or ("f" != filter and minmax_neighbor > neighbors[i]):
909 minmax_neighbor = neighbors[i]
910 if minmax_neighbor != minmax_start:
911 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
913 if not dir_to_target:
914 if 1 == get_map_score(eye_pos):
915 dir_to_target = rand_target_dir(neighbors, 0, dirs)
916 elif 3 >= get_map_score(eye_pos):
917 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
919 world_db["ThingActions"][id]["TA_NAME"]
922 elif dir_to_target and 3 < get_map_score(eye_pos):
924 elif "a" == filter and 10 <= get_map_score(eye_pos):
928 dir_to_target = False
930 run_i = 9 + 1 if "s" == filter else 1
931 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
934 mem_depth_c = b'9' if b' ' == mem_depth_c \
935 else bytes([mem_depth_c[0] - 1])
936 if libpr.dijkstra_map():
937 raise RuntimeError("No score map allocated for dijkstra_map().")
938 dir_to_target = get_dir_from_neighbors()
939 libpr.free_score_map()
940 if dir_to_target and str == type(dir_to_target):
941 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
942 if world_db["ThingActions"][id]["TA_NAME"]
944 t["T_ARGUMENT"] = ord(dir_to_target)
948 def standing_on_consumable(t):
949 """Return True/False whether t is standing on a consumable."""
950 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
951 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
952 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
953 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
959 def get_inventory_slot_to_consume(t):
960 """Return slot Id of strongest consumable in t's inventory, else -1."""
961 cmp_consumability = 0
964 for id in t["T_CARRIES"]:
965 type = world_db["Things"][id]["T_TYPE"]
966 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
967 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
974 """Determine next command/argment for actor t via AI algorithms.
976 AI will look for, and move towards, enemies (animate Things not of their
977 own ThingType); if they see none, they will consume consumables in their
978 inventory; if there are none, they will pick up what they stand on if they
979 stand on consumables; if they stand on none, they will move towards the
980 next consumable they see or remember on the map; if they see or remember
981 none, they will explore parts of the map unseen since ever or for at least
982 one turn; if there is nothing to explore, they will simply wait.
984 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
985 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
986 if not get_dir_to_target(t, "f"):
987 sel = get_inventory_slot_to_consume(t)
989 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
990 if world_db["ThingActions"][id]["TA_NAME"]
992 t["T_ARGUMENT"] = sel
993 elif standing_on_consumable(t):
994 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
995 if world_db["ThingActions"][id]["TA_NAME"]
997 elif (not get_dir_to_target(t, "c")) and \
998 (not get_dir_to_target(t, "a")):
999 get_dir_to_target(t, "s")
1003 """Run game world and its inhabitants until new player input expected."""
1005 whilebreaker = False
1006 while world_db["Things"][0]["T_LIFEPOINTS"]:
1007 for id in [id for id in world_db["Things"]]: # Only what's from start!
1008 if not id in world_db["Things"] or \
1009 world_db["Things"][id]["carried"]: # May have been consumed or
1010 continue # picked up during turn …
1011 Thing = world_db["Things"][id]
1012 if Thing["T_LIFEPOINTS"]:
1013 if not Thing["T_COMMAND"]:
1014 update_map_memory(Thing)
1020 Thing["T_PROGRESS"] += 1
1021 taid = [a for a in world_db["ThingActions"]
1022 if a == Thing["T_COMMAND"]][0]
1023 ThingAction = world_db["ThingActions"][taid]
1024 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1025 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1026 Thing["T_COMMAND"] = 0
1027 Thing["T_PROGRESS"] = 0
1029 thingproliferation(Thing)
1032 world_db["TURN"] += 1
1035 def new_Thing(type, pos=(0, 0)):
1036 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1038 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1050 "T_MEMDEPTHMAP": False,
1053 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1054 build_fov_map(thing)
1058 def id_setter(id, category, id_store=False, start_at_1=False):
1059 """Set ID of object of category to manipulate ID unused? Create new one.
1061 The ID is stored as id_store.id (if id_store is set). If the integer of the
1062 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
1063 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
1064 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
1065 new object is created, otherwise the new object's ID.
1067 min = 0 if start_at_1 else -32768
1068 max = 255 if start_at_1 else 32767
1070 id = integer_test(id, min, max)
1072 if id in world_db[category]:
1077 if (start_at_1 and 0 == id) \
1078 or ((not start_at_1) and (id < 0 or id > 255)):
1082 if id not in world_db[category]:
1086 "No unused ID available to add to ID list.")
1094 """Send PONG line to server output file."""
1095 strong_write(io_db["file_out"], "PONG\n")
1099 """Abort server process."""
1101 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1102 raise SystemExit("received QUIT command")
1105 def command_thingshere(str_y, str_x):
1106 """Write to out file list of Things known to player at coordinate y, x."""
1107 if world_db["WORLD_ACTIVE"]:
1108 y = integer_test(str_y, 0, 255)
1109 x = integer_test(str_x, 0, 255)
1110 length = world_db["MAP_LENGTH"]
1111 if None != y and None != x and y < length and x < length:
1112 pos = (y * world_db["MAP_LENGTH"]) + x
1113 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1114 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1115 for id in world_db["Things"]:
1116 if y == world_db["Things"][id]["T_POSY"] \
1117 and x == world_db["Things"][id]["T_POSX"] \
1118 and not world_db["Things"][id]["carried"]:
1119 type = world_db["Things"][id]["T_TYPE"]
1120 name = world_db["ThingTypes"][type]["TT_NAME"]
1121 strong_write(io_db["file_out"], name + "\n")
1123 for mt in world_db["Things"][0]["T_MEMTHING"]:
1124 if y == mt[1] and x == mt[2]:
1125 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1126 strong_write(io_db["file_out"], name + "\n")
1127 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1129 print("Ignoring: Invalid map coordinates.")
1131 print("Ignoring: Command only works on existing worlds.")
1134 def play_commander(action, args=False):
1135 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1137 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1141 id = [x for x in world_db["ThingActions"]
1142 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1143 world_db["Things"][0]["T_COMMAND"] = id
1146 def set_command_and_argument_int(str_arg):
1147 val = integer_test(str_arg, 0, 255)
1149 world_db["Things"][0]["T_ARGUMENT"] = val
1152 def set_command_and_argument_movestring(str_arg):
1153 if str_arg in directions_db:
1154 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1157 print("Ignoring: Argument must be valid direction string.")
1159 if action == "move":
1160 return set_command_and_argument_movestring
1162 return set_command_and_argument_int
1167 def command_seedrandomness(seed_string):
1168 """Set rand seed to int(seed_string)."""
1169 val = integer_test(seed_string, 0, 4294967295)
1174 def command_seedmap(seed_string):
1175 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1176 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1180 def command_makeworld(seed_string):
1181 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1183 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1184 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1185 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1186 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1187 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1188 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1189 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1195 err = "Space to put thing on too hard to find. Map too small?"
1197 y = rand.next() % world_db["MAP_LENGTH"]
1198 x = rand.next() % world_db["MAP_LENGTH"]
1199 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1203 raise SystemExit(err)
1204 # Replica of C code, wrongly ignores animatedness of new Thing.
1205 pos_clear = (0 == len([id for id in world_db["Things"]
1206 if world_db["Things"][id]["T_LIFEPOINTS"]
1207 if world_db["Things"][id]["T_POSY"] == y
1208 if world_db["Things"][id]["T_POSX"] == x]))
1213 val = integer_test(seed_string, 0, 4294967295)
1217 world_db["SEED_MAP"] = val
1218 player_will_be_generated = False
1219 playertype = world_db["PLAYER_TYPE"]
1220 for ThingType in world_db["ThingTypes"]:
1221 if playertype == ThingType:
1222 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1223 player_will_be_generated = True
1225 if not player_will_be_generated:
1226 print("Ignoring beyond SEED_MAP: " +
1227 "No player type with start number >0 defined.")
1230 for ThingAction in world_db["ThingActions"]:
1231 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1234 print("Ignoring beyond SEED_MAP: " +
1235 "No thing action with name 'wait' defined.")
1237 world_db["Things"] = {}
1239 world_db["WORLD_ACTIVE"] = 1
1240 world_db["TURN"] = 1
1241 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1242 id = id_setter(-1, "Things")
1243 world_db["Things"][id] = new_Thing(playertype, free_pos())
1244 update_map_memory(world_db["Things"][0])
1245 for type in world_db["ThingTypes"]:
1246 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1247 if type != playertype:
1248 id = id_setter(-1, "Things")
1249 world_db["Things"][id] = new_Thing(type, free_pos())
1250 strong_write(io_db["file_out"], "NEW_WORLD\n")
1253 def command_maplength(maplength_string):
1254 """Redefine map length. Invalidate map, therefore lose all things on it."""
1255 val = integer_test(maplength_string, 1, 256)
1257 world_db["MAP_LENGTH"] = val
1258 set_world_inactive()
1259 world_db["Things"] = {}
1260 libpr.set_maplength(val)
1263 def command_worldactive(worldactive_string):
1264 """Toggle world_db["WORLD_ACTIVE"] if possible.
1266 An active world can always be set inactive. An inactive world can only be
1267 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1268 activation, rebuild all Things' FOVs, and the player's map memory.
1270 # In original version, map existence was also tested (unnecessarily?).
1271 val = integer_test(worldactive_string, 0, 1)
1273 if 0 != world_db["WORLD_ACTIVE"]:
1275 set_world_inactive()
1277 print("World already active.")
1278 elif 0 == world_db["WORLD_ACTIVE"]:
1280 for ThingAction in world_db["ThingActions"]:
1281 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1284 player_exists = False
1285 for Thing in world_db["Things"]:
1287 player_exists = True
1289 if wait_exists and player_exists:
1290 for id in world_db["Things"]:
1291 if world_db["Things"][id]["T_LIFEPOINTS"]:
1292 build_fov_map(world_db["Things"][id])
1294 update_map_memory(world_db["Things"][id], False)
1295 world_db["WORLD_ACTIVE"] = 1
1298 def test_for_id_maker(object, category):
1299 """Return decorator testing for object having "id" attribute."""
1302 if hasattr(object, "id"):
1305 print("Ignoring: No " + category +
1306 " defined to manipulate yet.")
1311 def command_tid(id_string):
1312 """Set ID of Thing to manipulate. ID unused? Create new one.
1314 Default new Thing's type to the first available ThingType, others: zero.
1316 id = id_setter(id_string, "Things", command_tid)
1318 if world_db["ThingTypes"] == {}:
1319 print("Ignoring: No ThingType to settle new Thing in.")
1321 type = list(world_db["ThingTypes"].keys())[0]
1322 world_db["Things"][id] = new_Thing(type)
1325 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1329 def command_tcommand(str_int):
1330 """Set T_COMMAND of selected Thing."""
1331 val = integer_test(str_int, 0, 255)
1333 if 0 == val or val in world_db["ThingActions"]:
1334 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1336 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1340 def command_ttype(str_int):
1341 """Set T_TYPE of selected Thing."""
1342 val = integer_test(str_int, 0, 255)
1344 if val in world_db["ThingTypes"]:
1345 world_db["Things"][command_tid.id]["T_TYPE"] = val
1347 print("Ignoring: ThingType ID belongs to no known ThingType.")
1351 def command_tcarries(str_int):
1352 """Append int(str_int) to T_CARRIES of selected Thing.
1354 The ID int(str_int) must not be of the selected Thing, and must belong to a
1355 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1357 val = integer_test(str_int, 0, 255)
1359 if val == command_tid.id:
1360 print("Ignoring: Thing cannot carry itself.")
1361 elif val in world_db["Things"] \
1362 and not world_db["Things"][val]["carried"]:
1363 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1364 world_db["Things"][val]["carried"] = True
1366 print("Ignoring: Thing not available for carrying.")
1367 # Note that the whole carrying structure is different from the C version:
1368 # Carried-ness is marked by a "carried" flag, not by Things containing
1369 # Things internally.
1373 def command_tmemthing(str_t, str_y, str_x):
1374 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1376 The type must fit to an existing ThingType, and the position into the map.
1378 type = integer_test(str_t, 0, 255)
1379 posy = integer_test(str_y, 0, 255)
1380 posx = integer_test(str_x, 0, 255)
1381 if None != type and None != posy and None != posx:
1382 if type not in world_db["ThingTypes"] \
1383 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1384 print("Ignoring: Illegal value for thing type or position.")
1386 memthing = (type, posy, posx)
1387 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1390 def setter_map(maptype):
1391 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1393 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1396 def helper(str_int, mapline):
1397 val = integer_test(str_int, 0, 255)
1399 if val >= world_db["MAP_LENGTH"]:
1400 print("Illegal value for map line number.")
1401 elif len(mapline) != world_db["MAP_LENGTH"]:
1402 print("Map line length is unequal map width.")
1404 length = world_db["MAP_LENGTH"]
1406 if not world_db["Things"][command_tid.id][maptype]:
1407 map = bytearray(b' ' * (length ** 2))
1409 map = world_db["Things"][command_tid.id][maptype]
1410 map[val * length:(val * length) + length] = mapline.encode()
1411 world_db["Things"][command_tid.id][maptype] = map
1415 def setter_tpos(axis):
1416 """Generate setter for T_POSX or T_POSY of selected Thing.
1418 If world is active, rebuilds animate things' fovmap, player's memory map.
1421 def helper(str_int):
1422 val = integer_test(str_int, 0, 255)
1424 if val < world_db["MAP_LENGTH"]:
1425 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1426 if world_db["WORLD_ACTIVE"] \
1427 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1428 build_fov_map(world_db["Things"][command_tid.id])
1429 if 0 == command_tid.id:
1430 update_map_memory(world_db["Things"][command_tid.id])
1432 print("Ignoring: Position is outside of map.")
1436 def command_ttid(id_string):
1437 """Set ID of ThingType to manipulate. ID unused? Create new one.
1439 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1441 id = id_setter(id_string, "ThingTypes", command_ttid)
1443 world_db["ThingTypes"][id] = {
1444 "TT_NAME": "(none)",
1447 "TT_PROLIFERATE": 0,
1448 "TT_START_NUMBER": 0,
1454 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1458 def command_ttname(name):
1459 """Set TT_NAME of selected ThingType."""
1460 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1464 def command_ttsymbol(char):
1465 """Set TT_SYMBOL of selected ThingType. """
1467 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1469 print("Ignoring: Argument must be single character.")
1473 def command_ttcorpseid(str_int):
1474 """Set TT_CORPSE_ID of selected ThingType."""
1475 val = integer_test(str_int, 0, 255)
1477 if val in world_db["ThingTypes"]:
1478 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1480 print("Ignoring: Corpse ID belongs to no known ThignType.")
1483 def command_taid(id_string):
1484 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1486 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1488 id = id_setter(id_string, "ThingActions", command_taid, True)
1490 world_db["ThingActions"][id] = {
1496 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1499 @test_ThingAction_id
1500 def command_taname(name):
1501 """Set TA_NAME of selected ThingAction.
1503 The name must match a valid thing action function. If after the name
1504 setting no ThingAction with name "wait" remains, call set_world_inactive().
1506 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1507 or name == "pick_up":
1508 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1509 if 1 == world_db["WORLD_ACTIVE"]:
1510 wait_defined = False
1511 for id in world_db["ThingActions"]:
1512 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1515 if not wait_defined:
1516 set_world_inactive()
1518 print("Ignoring: Invalid action name.")
1519 # In contrast to the original,naming won't map a function to a ThingAction.
1523 """Call ai() on player Thing, then turn_over()."""
1524 ai(world_db["Things"][0])
1528 """Commands database.
1530 Map command start tokens to ([0]) number of expected command arguments, ([1])
1531 the command's meta-ness (i.e. is it to be written to the record file, is it to
1532 be ignored in replay mode if read from server input file), and ([2]) a function
1536 "QUIT": (0, True, command_quit),
1537 "PING": (0, True, command_ping),
1538 "THINGS_HERE": (2, True, command_thingshere),
1539 "MAKE_WORLD": (1, False, command_makeworld),
1540 "SEED_MAP": (1, False, command_seedmap),
1541 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1542 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1543 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1544 "MAP_LENGTH": (1, False, command_maplength),
1545 "WORLD_ACTIVE": (1, False, command_worldactive),
1546 "TA_ID": (1, False, command_taid),
1547 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1548 "TA_NAME": (1, False, command_taname),
1549 "TT_ID": (1, False, command_ttid),
1550 "TT_NAME": (1, False, command_ttname),
1551 "TT_SYMBOL": (1, False, command_ttsymbol),
1552 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1553 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1555 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1557 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1559 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1560 "T_ID": (1, False, command_tid),
1561 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1562 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1563 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1564 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1565 "T_COMMAND": (1, False, command_tcommand),
1566 "T_TYPE": (1, False, command_ttype),
1567 "T_CARRIES": (1, False, command_tcarries),
1568 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1569 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1570 "T_MEMTHING": (3, False, command_tmemthing),
1571 "T_POSY": (1, False, setter_tpos("Y")),
1572 "T_POSX": (1, False, setter_tpos("X")),
1573 "wait": (0, False, play_commander("wait")),
1574 "move": (1, False, play_commander("move")),
1575 "pick_up": (0, False, play_commander("pick_up")),
1576 "drop": (1, False, play_commander("drop", True)),
1577 "use": (1, False, play_commander("use", True)),
1578 "ai": (0, False, command_ai)
1582 """World state database. With sane default values. (Randomness is in rand.)"""
1594 """Mapping of direction names to internal direction chars."""
1595 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1596 "west": "s", "north-west": "w", "north-east": "e"}
1598 """File IO database."""
1600 "path_save": "save",
1601 "path_record": "record",
1602 "path_worldconf": "confserver/world",
1603 "path_server": "server/",
1604 "path_in": "server/in",
1605 "path_out": "server/out",
1606 "path_worldstate": "server/worldstate",
1607 "tmp_suffix": "_tmp",
1608 "kicked_by_rival": False,
1609 "worldstate_updateable": False
1614 libpr = prep_library()
1615 rand = RandomnessIO()
1617 opts = parse_command_line_arguments()
1619 io_db["verbose"] = True
1620 if None != opts.replay:
1624 except SystemExit as exit:
1625 print("ABORTING: " + exit.args[0])
1627 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")