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), flush(), and os.fsync() to file."""
65 def setup_server_io():
66 """Fill IO files DB with proper file( path)s. Write process IO test string.
68 Ensure IO files directory at server/. Remove any old input file if found.
69 Set up new input file for reading, and new output file for writing. Start
70 output file with process hash line of format PID + " " + floated UNIX time
71 (io_db["teststring"]). Raise SystemExit if file is found at path of either
72 record or save file plus io_db["tmp_suffix"].
74 def detect_atomic_leftover(path, tmp_suffix):
75 path_tmp = path + tmp_suffix
76 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
77 "aborted previous attempt to write '" + path + "'. Aborting " \
78 "until matter is resolved by removing it from its current path."
79 if os.access(path_tmp, os.F_OK):
81 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
82 io_db["save_wait"] = 0
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_out", "path_out")
105 helper("file_in", "path_in")
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.
125 print("input " + prefix + ": " + command)
127 tokens = shlex.split(command, comments=True)
128 except ValueError as err:
129 print("Can't tokenize command string: " + str(err) + ".")
131 if len(tokens) > 0 and tokens[0] in commands_db \
132 and len(tokens) == commands_db[tokens[0]][0] + 1:
133 if commands_db[tokens[0]][1]:
134 commands_db[tokens[0]][2](*tokens[1:])
136 print("Due to replay mode, reading command as 'go on in record'.")
137 line = io_db["file_record"].readline()
139 obey(line.rstrip(), io_db["file_record"].prefix
140 + str(io_db["file_record"].line_n))
141 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
143 print("Reached end of record file.")
145 commands_db[tokens[0]][2](*tokens[1:])
147 io_db["record_chunk"] += command + "\n"
148 if time.time() > io_db["save_wait"] + 15:
149 atomic_write(io_db["path_record"], io_db["record_chunk"],
152 io_db["record_chunk"] = ""
153 io_db["save_wait"] = time.time()
154 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
155 elif 0 != len(tokens):
156 print("Invalid command/argument, or bad number of tokens.")
159 def atomic_write(path, text, do_append=False):
160 """Atomic write of text to file at path, appended if do_append is set."""
161 path_tmp = path + io_db["tmp_suffix"]
165 if os.access(path, os.F_OK):
166 shutil.copyfile(path, path_tmp)
167 file = open(path_tmp, mode)
168 strong_write(file, text)
170 if os.access(path, os.F_OK):
172 os.rename(path_tmp, path)
176 """Save all commands needed to reconstruct current world state."""
179 string = string.replace("\u005C", '\u005C\u005C')
180 return '"' + string.replace('"', '\u005C"') + '"'
185 if world_db["Things"][id][key]:
186 map = world_db["Things"][id][key]
187 length = world_db["MAP_LENGTH"]
188 for i in range(length):
189 line = map[i * length:(i * length) + length].decode()
190 string = string + key + " " + str(i) + " " + quote(line) \
197 for memthing in world_db["Things"][id]["T_MEMTHING"]:
198 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
199 str(memthing[1]) + " " + str(memthing[2]) + "\n"
202 def helper(category, id_string, special_keys={}):
204 for id in world_db[category]:
205 string = string + id_string + " " + str(id) + "\n"
206 for key in world_db[category][id]:
207 if not key in special_keys:
208 x = world_db[category][id][key]
209 argument = quote(x) if str == type(x) else str(x)
210 string = string + key + " " + argument + "\n"
211 elif special_keys[key]:
212 string = string + special_keys[key](id)
217 if dict != type(world_db[key]) and key != "MAP" and \
218 key != "WORLD_ACTIVE" and key != "SEED_MAP":
219 string = string + key + " " + str(world_db[key]) + "\n"
220 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
221 string = string + helper("ThingActions", "TA_ID")
222 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
223 for id in world_db["ThingTypes"]:
224 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
225 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
226 string = string + helper("Things", "T_ID",
227 {"T_CARRIES": False, "carried": False,
228 "T_MEMMAP": mapsetter("T_MEMMAP"),
229 "T_MEMTHING": memthing, "fovmap": False,
230 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
231 for id in world_db["Things"]:
232 if [] != world_db["Things"][id]["T_CARRIES"]:
233 string = string + "T_ID " + str(id) + "\n"
234 for carried_id in world_db["Things"][id]["T_CARRIES"]:
235 string = string + "T_CARRIES " + str(carried_id) + "\n"
236 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
237 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
238 atomic_write(io_db["path_save"], string)
241 def obey_lines_in_file(path, name, do_record=False):
242 """Call obey() on each line of path's file, use name in input prefix."""
243 file = open(path, "r")
245 for line in file.readlines():
246 obey(line.rstrip(), name + "file line " + str(line_n),
252 def parse_command_line_arguments():
253 """Return settings values read from command line arguments."""
254 parser = argparse.ArgumentParser()
255 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
257 opts, unknown = parser.parse_known_args()
262 """Ensure valid server out file belonging to current process.
264 This is done by comparing io_db["teststring"] to what's found at the start
265 of the current file at io_db["path_out"]. On failure, set
266 io_db["kicked_by_rival"] and raise SystemExit.
268 if not os.access(io_db["path_out"], os.F_OK):
269 raise SystemExit("Server output file has disappeared.")
270 file = open(io_db["path_out"], "r")
271 test = file.readline().rstrip("\n")
273 if test != io_db["teststring"]:
274 io_db["kicked_by_rival"] = True
275 msg = "Server test string in server output file does not match. This" \
276 " indicates that the current server process has been " \
277 "superseded by another one."
278 raise SystemExit(msg)
282 """Return next newline-delimited command from server in file.
284 Keep building return string until a newline is encountered. Pause between
285 unsuccessful reads, and after too much waiting, run server_test().
287 wait_on_fail = 0.03333
292 add = io_db["file_in"].readline()
294 command = command + add
295 if len(command) > 0 and "\n" == command[-1]:
296 command = command[:-1]
299 time.sleep(wait_on_fail)
300 if now + max_wait < time.time():
306 def try_worldstate_update():
307 """Write worldstate file if io_db["worldstate_updateable"] is set."""
308 if io_db["worldstate_updateable"]:
310 def draw_visible_Things(map, run):
311 for id in world_db["Things"]:
312 type = world_db["Things"][id]["T_TYPE"]
313 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
314 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
315 if (0 == run and not consumable and not alive) \
316 or (1 == run and consumable and not alive) \
317 or (2 == run and alive):
318 y = world_db["Things"][id]["T_POSY"]
319 x = world_db["Things"][id]["T_POSX"]
320 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
321 if 'v' == chr(fovflag):
322 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
323 map[(y * length) + x] = ord(c)
325 def write_map(string, map):
326 for i in range(length):
327 line = map[i * length:(i * length) + length].decode()
328 string = string + line + "\n"
332 if [] == world_db["Things"][0]["T_CARRIES"]:
333 inventory = "(none)\n"
335 for id in world_db["Things"][0]["T_CARRIES"]:
336 type_id = world_db["Things"][id]["T_TYPE"]
337 name = world_db["ThingTypes"][type_id]["TT_NAME"]
338 inventory = inventory + name + "\n"
339 string = str(world_db["TURN"]) + "\n" + \
340 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
341 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
342 inventory + "%\n" + \
343 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
344 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
345 str(world_db["MAP_LENGTH"]) + "\n"
346 length = world_db["MAP_LENGTH"]
347 fov = bytearray(b' ' * (length ** 2))
348 for pos in range(length ** 2):
349 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
350 fov[pos] = world_db["MAP"][pos]
352 draw_visible_Things(fov, i)
353 string = write_map(string, fov)
354 mem = world_db["Things"][0]["T_MEMMAP"][:]
356 for mt in world_db["Things"][0]["T_MEMTHING"]:
357 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
358 if (i == 0 and not consumable) or (i == 1 and consumable):
359 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
360 mem[(mt[1] * length) + mt[2]] = ord(c)
361 string = write_map(string, mem)
362 atomic_write(io_db["path_worldstate"], string)
363 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
364 io_db["worldstate_updateable"] = False
368 """Replay game from record file.
370 Use opts.replay as breakpoint turn to which to replay automatically before
371 switching to manual input by non-meta commands in server input file
372 triggering further reads of record file. Ensure opts.replay is at least 1.
373 Run try_worldstate_update() before each interactive obey()/read_command().
377 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
378 " (if so late a turn is to be found).")
379 if not os.access(io_db["path_record"], os.F_OK):
380 raise SystemExit("No record file found to replay.")
381 io_db["file_record"] = open(io_db["path_record"], "r")
382 io_db["file_record"].prefix = "record file line "
383 io_db["file_record"].line_n = 1
384 while world_db["TURN"] < opts.replay:
385 line = io_db["file_record"].readline()
388 obey(line.rstrip(), io_db["file_record"].prefix
389 + str(io_db["file_record"].line_n))
390 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
392 try_worldstate_update()
393 obey(read_command(), "in file", replay=True)
397 """Play game by server input file commands. Before, load save file found.
399 If no save file is found, a new world is generated from the commands in the
400 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
401 command and all that follow via the server input file. Run
402 try_worldstate_update() before each interactive obey()/read_command().
404 if os.access(io_db["path_save"], os.F_OK):
405 obey_lines_in_file(io_db["path_save"], "save")
407 if not os.access(io_db["path_worldconf"], os.F_OK):
408 msg = "No world config file from which to start a new world."
409 raise SystemExit(msg)
410 obey_lines_in_file(io_db["path_worldconf"], "world config ",
412 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
414 try_worldstate_update()
415 obey(read_command(), "in file", do_record=True)
419 """(Re-)make island map.
421 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
422 start with one land cell in the middle, then go into cycle of repeatedly
423 selecting a random sea cell and transforming it into land if it is neighbor
424 to land. The cycle ends when a land cell is due to be created at the map's
425 border. Then put some trees on the map (TODO: more precise algorithm desc).
427 def is_neighbor(coordinates, type):
430 length = world_db["MAP_LENGTH"]
432 diag_west = x + (ind > 0)
433 diag_east = x + (ind < (length - 1))
434 pos = (y * length) + x
435 if (y > 0 and diag_east
436 and type == chr(world_db["MAP"][pos - length + ind])) \
438 and type == chr(world_db["MAP"][pos + 1])) \
439 or (y < (length - 1) and diag_east
440 and type == chr(world_db["MAP"][pos + length + ind])) \
441 or (y > 0 and diag_west
442 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
444 and type == chr(world_db["MAP"][pos - 1])) \
445 or (y < (length - 1) and diag_west
446 and type == chr(world_db["MAP"][pos + length - (not ind)])):
449 store_seed = rand.seed
450 rand.seed = world_db["SEED_MAP"]
451 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
452 length = world_db["MAP_LENGTH"]
453 add_half_width = (not (length % 2)) * int(length / 2)
454 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
456 y = rand.next() % length
457 x = rand.next() % length
458 pos = (y * length) + x
459 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
460 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
462 world_db["MAP"][pos] = ord(".")
463 n_trees = int((length ** 2) / 16)
465 while (i_trees <= n_trees):
466 single_allowed = rand.next() % 32
467 y = rand.next() % length
468 x = rand.next() % length
469 pos = (y * length) + x
470 if "." == chr(world_db["MAP"][pos]) \
471 and ((not single_allowed) or is_neighbor((y, x), "X")):
472 world_db["MAP"][pos] = ord("X")
474 rand.seed = store_seed
475 # This all-too-precise replica of the original C code misses iter_limit().
478 def update_map_memory(t, age_map=True):
479 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
480 if not t["T_MEMMAP"]:
481 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
482 if not t["T_MEMDEPTHMAP"]:
483 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
484 for pos in range(world_db["MAP_LENGTH"] ** 2):
485 if "v" == chr(t["fovmap"][pos]):
486 t["T_MEMDEPTHMAP"][pos] = ord("0")
487 if " " == chr(t["T_MEMMAP"][pos]):
488 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
490 if age_map and ord('0') <= t["T_MEMDEPTHMAP"][pos] \
491 and ord('9') > t["T_MEMDEPTHMAP"][pos] \
492 and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)):
493 t["T_MEMDEPTHMAP"][pos] += 1
494 for mt in [mt for mt in t["T_MEMTHING"]
495 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
497 t["T_MEMTHING"].remove(mt)
498 for id in [id for id in world_db["Things"]
499 if not world_db["Things"][id]["carried"]]:
500 type = world_db["Things"][id]["T_TYPE"]
501 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
502 y = world_db["Things"][id]["T_POSY"]
503 x = world_db["Things"][id]["T_POSX"]
504 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
505 t["T_MEMTHING"].append((type, y, x))
508 def set_world_inactive():
509 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
511 if os.access(io_db["path_worldstate"], os.F_OK):
512 os.remove(io_db["path_worldstate"])
513 world_db["WORLD_ACTIVE"] = 0
516 def integer_test(val_string, min, max):
517 """Return val_string if possible integer >= min and <= max, else None."""
519 val = int(val_string)
520 if val < min or val > max:
524 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
529 def setter(category, key, min, max):
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 set_map_score(pos, score):
789 test = libpr.set_map_score(pos, score)
791 raise RuntimeError("No score map allocated for set_map_score().")
793 def get_map_score(pos):
794 result = libpr.get_map_score(pos)
796 raise RuntimeError("No score map allocated for get_map_score().")
800 if t["fovmap"] and ("a" == filter or "f" == filter):
801 for id in world_db["Things"]:
802 Thing = world_db["Things"][id]
803 if Thing != t and Thing["T_LIFEPOINTS"] and \
804 t["T_TYPE"] != Thing["T_TYPE"] and \
805 'v' == chr(t["fovmap"][(Thing["T_POSY"]
806 * world_db["MAP_LENGTH"])
808 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
809 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
811 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
814 elif t["T_MEMMAP"] and "c" == filter:
815 for mt in t["T_MEMTHING"]:
816 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
818 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
822 def init_score_map():
823 test = libpr.init_score_map()
825 raise RuntimeError("Malloc error in init_score_map().")
826 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
827 if '.' == chr(t["T_MEMMAP"][i])]:
828 set_map_score(i, 65535 - 1)
830 for id in world_db["Things"]:
831 Thing = world_db["Things"][id]
832 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
834 if t != Thing and Thing["T_LIFEPOINTS"] and \
835 t["T_TYPE"] != Thing["T_TYPE"] and \
836 'v' == chr(t["fovmap"][pos]) and \
837 t["T_LIFEPOINTS"] > \
838 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
839 set_map_score(pos, 0)
840 elif t["T_TYPE"] == Thing["T_TYPE"]:
841 set_map_score(pos, 65535)
843 for id in [id for id in world_db["Things"]
844 if world_db["Things"][id]["T_LIFEPOINTS"]]:
845 Thing = world_db["Things"][id]
846 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
848 if t["T_TYPE"] != Thing["T_TYPE"] and \
849 'v' == chr(t["fovmap"][pos]) and \
850 t["T_LIFEPOINTS"] <= \
851 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
852 set_map_score(pos, 0)
854 for mt in [mt for mt in t["T_MEMTHING"]
855 if ' ' != chr(t["T_MEMMAP"][mt[1]
856 * world_db["MAP_LENGTH"]
858 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
859 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
861 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
862 if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
865 def rand_target_dir(neighbors, cmp, dirs):
868 for i in range(len(dirs)):
869 if cmp == neighbors[i]:
870 candidates.append(dirs[i])
872 return candidates[rand.next() % n_candidates] if n_candidates else 0
874 def get_neighbor_scores(dirs, eye_pos):
876 if libpr.ready_neighbor_scores(eye_pos):
877 raise RuntimeError("No score map allocated for " +
878 "ready_neighbor_scores.()")
879 for i in range(len(dirs)):
880 scores.append(libpr.get_neighbor_score(i))
883 def get_dir_from_neighbors():
884 dir_to_target = False
886 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
887 neighbors = get_neighbor_scores(dirs, eye_pos)
889 inhabited = [world_db["Things"][id]["T_POSY"]
890 * world_db["MAP_LENGTH"]
891 + world_db["Things"][id]["T_POSX"]
892 for id in world_db["Things"]
893 if world_db["Things"][id]["T_LIFEPOINTS"]]
894 for i in range(len(dirs)):
895 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
896 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
898 for pos in [pos for pos in inhabited if pos == pos_cmp]:
901 minmax_start = 0 if "f" == filter else 65535 - 1
902 minmax_neighbor = minmax_start
903 for i in range(len(dirs)):
904 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
905 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
906 or ("f" != filter and minmax_neighbor > neighbors[i]):
907 minmax_neighbor = neighbors[i]
908 if minmax_neighbor != minmax_start:
909 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
911 if not dir_to_target:
912 if 1 == get_map_score(eye_pos):
913 dir_to_target = rand_target_dir(neighbors, 0, dirs)
914 elif 3 >= get_map_score(eye_pos):
915 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
917 world_db["ThingActions"][id]["TA_NAME"]
920 elif dir_to_target and 3 < get_map_score(eye_pos):
922 elif "a" == filter and 10 <= get_map_score(eye_pos):
926 dir_to_target = False
928 run_i = 9 + 1 if "s" == filter else 1
929 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
932 mem_depth_c = b'9' if b' ' == mem_depth_c \
933 else bytes([mem_depth_c[0] - 1])
934 if libpr.dijkstra_map():
935 raise RuntimeError("No score map allocated for dijkstra_map().")
936 dir_to_target = get_dir_from_neighbors()
937 libpr.free_score_map()
938 if dir_to_target and str == type(dir_to_target):
939 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
940 if world_db["ThingActions"][id]["TA_NAME"]
942 t["T_ARGUMENT"] = ord(dir_to_target)
946 def standing_on_consumable(t):
947 """Return True/False whether t is standing on a consumable."""
948 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
949 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
950 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
951 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
957 def get_inventory_slot_to_consume(t):
958 """Return slot Id of strongest consumable in t's inventory, else -1."""
959 cmp_consumability = 0
962 for id in t["T_CARRIES"]:
963 type = world_db["Things"][id]["T_TYPE"]
964 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
965 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
972 """Determine next command/argment for actor t via AI algorithms.
974 AI will look for, and move towards, enemies (animate Things not of their
975 own ThingType); if they see none, they will consume consumables in their
976 inventory; if there are none, they will pick up what they stand on if they
977 stand on consumables; if they stand on none, they will move towards the
978 next consumable they see or remember on the map; if they see or remember
979 none, they will explore parts of the map unseen since ever or for at least
980 one turn; if there is nothing to explore, they will simply wait.
982 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
983 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
984 if not get_dir_to_target(t, "f"):
985 sel = get_inventory_slot_to_consume(t)
987 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
988 if world_db["ThingActions"][id]["TA_NAME"]
990 t["T_ARGUMENT"] = sel
991 elif standing_on_consumable(t):
992 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
993 if world_db["ThingActions"][id]["TA_NAME"]
995 elif (not get_dir_to_target(t, "c")) and \
996 (not get_dir_to_target(t, "a")):
997 get_dir_to_target(t, "s")
1001 """Run game world and its inhabitants until new player input expected."""
1003 whilebreaker = False
1004 while world_db["Things"][0]["T_LIFEPOINTS"]:
1005 for id in [id for id in world_db["Things"]]: # Only what's from start!
1006 if not id in world_db["Things"] or \
1007 world_db["Things"][id]["carried"]: # May have been consumed or
1008 continue # picked up during turn …
1009 Thing = world_db["Things"][id]
1010 if Thing["T_LIFEPOINTS"]:
1011 if not Thing["T_COMMAND"]:
1012 update_map_memory(Thing)
1018 Thing["T_PROGRESS"] += 1
1019 taid = [a for a in world_db["ThingActions"]
1020 if a == Thing["T_COMMAND"]][0]
1021 ThingAction = world_db["ThingActions"][taid]
1022 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1023 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1024 Thing["T_COMMAND"] = 0
1025 Thing["T_PROGRESS"] = 0
1027 thingproliferation(Thing)
1030 world_db["TURN"] += 1
1033 def new_Thing(type, pos=(0, 0)):
1034 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1036 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1048 "T_MEMDEPTHMAP": False,
1051 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1052 build_fov_map(thing)
1056 def id_setter(id, category, id_store=False, start_at_1=False):
1057 """Set ID of object of category to manipulate ID unused? Create new one.
1059 The ID is stored as id_store.id (if id_store is set). If the integer of the
1060 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
1061 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
1062 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
1063 new object is created, otherwise the new object's ID.
1065 min = 0 if start_at_1 else -32768
1066 max = 255 if start_at_1 else 32767
1068 id = integer_test(id, min, max)
1070 if id in world_db[category]:
1075 if (start_at_1 and 0 == id) \
1076 or ((not start_at_1) and (id < 0 or id > 255)):
1080 if id not in world_db[category]:
1084 "No unused ID available to add to ID list.")
1092 """Send PONG line to server output file."""
1093 strong_write(io_db["file_out"], "PONG\n")
1097 """Abort server process."""
1099 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1100 raise SystemExit("received QUIT command")
1103 def command_thingshere(str_y, str_x):
1104 """Write to out file list of Things known to player at coordinate y, x."""
1105 if world_db["WORLD_ACTIVE"]:
1106 y = integer_test(str_y, 0, 255)
1107 x = integer_test(str_x, 0, 255)
1108 length = world_db["MAP_LENGTH"]
1109 if None != y and None != x and y < length and x < length:
1110 pos = (y * world_db["MAP_LENGTH"]) + x
1111 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1112 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1113 for id in world_db["Things"]:
1114 if y == world_db["Things"][id]["T_POSY"] \
1115 and x == world_db["Things"][id]["T_POSX"] \
1116 and not world_db["Things"][id]["carried"]:
1117 type = world_db["Things"][id]["T_TYPE"]
1118 name = world_db["ThingTypes"][type]["TT_NAME"]
1119 strong_write(io_db["file_out"], name + "\n")
1121 for mt in world_db["Things"][0]["T_MEMTHING"]:
1122 if y == mt[1] and x == mt[2]:
1123 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1124 strong_write(io_db["file_out"], name + "\n")
1125 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1127 print("Ignoring: Invalid map coordinates.")
1129 print("Ignoring: Command only works on existing worlds.")
1132 def play_commander(action, args=False):
1133 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1135 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1139 id = [x for x in world_db["ThingActions"]
1140 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1141 world_db["Things"][0]["T_COMMAND"] = id
1144 def set_command_and_argument_int(str_arg):
1145 val = integer_test(str_arg, 0, 255)
1147 world_db["Things"][0]["T_ARGUMENT"] = val
1150 def set_command_and_argument_movestring(str_arg):
1151 if str_arg in directions_db:
1152 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1155 print("Ignoring: Argument must be valid direction string.")
1157 if action == "move":
1158 return set_command_and_argument_movestring
1160 return set_command_and_argument_int
1165 def command_seedrandomness(seed_string):
1166 """Set rand seed to int(seed_string)."""
1167 val = integer_test(seed_string, 0, 4294967295)
1172 def command_seedmap(seed_string):
1173 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1174 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1178 def command_makeworld(seed_string):
1179 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1181 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1182 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1183 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1184 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1185 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1186 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1187 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1193 err = "Space to put thing on too hard to find. Map too small?"
1195 y = rand.next() % world_db["MAP_LENGTH"]
1196 x = rand.next() % world_db["MAP_LENGTH"]
1197 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1201 raise SystemExit(err)
1202 # Replica of C code, wrongly ignores animatedness of new Thing.
1203 pos_clear = (0 == len([id for id in world_db["Things"]
1204 if world_db["Things"][id]["T_LIFEPOINTS"]
1205 if world_db["Things"][id]["T_POSY"] == y
1206 if world_db["Things"][id]["T_POSX"] == x]))
1211 val = integer_test(seed_string, 0, 4294967295)
1215 world_db["SEED_MAP"] = val
1216 player_will_be_generated = False
1217 playertype = world_db["PLAYER_TYPE"]
1218 for ThingType in world_db["ThingTypes"]:
1219 if playertype == ThingType:
1220 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1221 player_will_be_generated = True
1223 if not player_will_be_generated:
1224 print("Ignoring beyond SEED_MAP: " +
1225 "No player type with start number >0 defined.")
1228 for ThingAction in world_db["ThingActions"]:
1229 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1232 print("Ignoring beyond SEED_MAP: " +
1233 "No thing action with name 'wait' defined.")
1235 world_db["Things"] = {}
1237 world_db["WORLD_ACTIVE"] = 1
1238 world_db["TURN"] = 1
1239 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1240 id = id_setter(-1, "Things")
1241 world_db["Things"][id] = new_Thing(playertype, free_pos())
1242 update_map_memory(world_db["Things"][0])
1243 for type in world_db["ThingTypes"]:
1244 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1245 if type != playertype:
1246 id = id_setter(-1, "Things")
1247 world_db["Things"][id] = new_Thing(type, free_pos())
1248 strong_write(io_db["file_out"], "NEW_WORLD\n")
1251 def command_maplength(maplength_string):
1252 """Redefine map length. Invalidate map, therefore lose all things on it."""
1253 val = integer_test(maplength_string, 1, 256)
1255 world_db["MAP_LENGTH"] = val
1256 set_world_inactive()
1257 world_db["Things"] = {}
1258 libpr.set_maplength(val)
1261 def command_worldactive(worldactive_string):
1262 """Toggle world_db["WORLD_ACTIVE"] if possible.
1264 An active world can always be set inactive. An inactive world can only be
1265 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1266 activation, rebuild all Things' FOVs, and the player's map memory.
1268 # In original version, map existence was also tested (unnecessarily?).
1269 val = integer_test(worldactive_string, 0, 1)
1271 if 0 != world_db["WORLD_ACTIVE"]:
1273 set_world_inactive()
1275 print("World already active.")
1276 elif 0 == world_db["WORLD_ACTIVE"]:
1278 for ThingAction in world_db["ThingActions"]:
1279 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1282 player_exists = False
1283 for Thing in world_db["Things"]:
1285 player_exists = True
1287 if wait_exists and player_exists:
1288 for id in world_db["Things"]:
1289 if world_db["Things"][id]["T_LIFEPOINTS"]:
1290 build_fov_map(world_db["Things"][id])
1292 update_map_memory(world_db["Things"][id], False)
1293 world_db["WORLD_ACTIVE"] = 1
1296 def test_for_id_maker(object, category):
1297 """Return decorator testing for object having "id" attribute."""
1300 if hasattr(object, "id"):
1303 print("Ignoring: No " + category +
1304 " defined to manipulate yet.")
1309 def command_tid(id_string):
1310 """Set ID of Thing to manipulate. ID unused? Create new one.
1312 Default new Thing's type to the first available ThingType, others: zero.
1314 id = id_setter(id_string, "Things", command_tid)
1316 if world_db["ThingTypes"] == {}:
1317 print("Ignoring: No ThingType to settle new Thing in.")
1319 type = list(world_db["ThingTypes"].keys())[0]
1320 world_db["Things"][id] = new_Thing(type)
1323 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1327 def command_tcommand(str_int):
1328 """Set T_COMMAND of selected Thing."""
1329 val = integer_test(str_int, 0, 255)
1331 if 0 == val or val in world_db["ThingActions"]:
1332 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1334 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1338 def command_ttype(str_int):
1339 """Set T_TYPE of selected Thing."""
1340 val = integer_test(str_int, 0, 255)
1342 if val in world_db["ThingTypes"]:
1343 world_db["Things"][command_tid.id]["T_TYPE"] = val
1345 print("Ignoring: ThingType ID belongs to no known ThingType.")
1349 def command_tcarries(str_int):
1350 """Append int(str_int) to T_CARRIES of selected Thing.
1352 The ID int(str_int) must not be of the selected Thing, and must belong to a
1353 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1355 val = integer_test(str_int, 0, 255)
1357 if val == command_tid.id:
1358 print("Ignoring: Thing cannot carry itself.")
1359 elif val in world_db["Things"] \
1360 and not world_db["Things"][val]["carried"]:
1361 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1362 world_db["Things"][val]["carried"] = True
1364 print("Ignoring: Thing not available for carrying.")
1365 # Note that the whole carrying structure is different from the C version:
1366 # Carried-ness is marked by a "carried" flag, not by Things containing
1367 # Things internally.
1371 def command_tmemthing(str_t, str_y, str_x):
1372 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1374 The type must fit to an existing ThingType, and the position into the map.
1376 type = integer_test(str_t, 0, 255)
1377 posy = integer_test(str_y, 0, 255)
1378 posx = integer_test(str_x, 0, 255)
1379 if None != type and None != posy and None != posx:
1380 if type not in world_db["ThingTypes"] \
1381 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1382 print("Ignoring: Illegal value for thing type or position.")
1384 memthing = (type, posy, posx)
1385 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1388 def setter_map(maptype):
1389 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1391 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1394 def helper(str_int, mapline):
1395 val = integer_test(str_int, 0, 255)
1397 if val >= world_db["MAP_LENGTH"]:
1398 print("Illegal value for map line number.")
1399 elif len(mapline) != world_db["MAP_LENGTH"]:
1400 print("Map line length is unequal map width.")
1402 length = world_db["MAP_LENGTH"]
1404 if not world_db["Things"][command_tid.id][maptype]:
1405 map = bytearray(b' ' * (length ** 2))
1407 map = world_db["Things"][command_tid.id][maptype]
1408 map[val * length:(val * length) + length] = mapline.encode()
1409 world_db["Things"][command_tid.id][maptype] = map
1413 def setter_tpos(axis):
1414 """Generate setter for T_POSX or T_POSY of selected Thing.
1416 If world is active, rebuilds animate things' fovmap, player's memory map.
1419 def helper(str_int):
1420 val = integer_test(str_int, 0, 255)
1422 if val < world_db["MAP_LENGTH"]:
1423 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1424 if world_db["WORLD_ACTIVE"] \
1425 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1426 build_fov_map(world_db["Things"][command_tid.id])
1427 if 0 == command_tid.id:
1428 update_map_memory(world_db["Things"][command_tid.id])
1430 print("Ignoring: Position is outside of map.")
1434 def command_ttid(id_string):
1435 """Set ID of ThingType to manipulate. ID unused? Create new one.
1437 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1439 id = id_setter(id_string, "ThingTypes", command_ttid)
1441 world_db["ThingTypes"][id] = {
1442 "TT_NAME": "(none)",
1445 "TT_PROLIFERATE": 0,
1446 "TT_START_NUMBER": 0,
1452 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1456 def command_ttname(name):
1457 """Set TT_NAME of selected ThingType."""
1458 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1462 def command_ttsymbol(char):
1463 """Set TT_SYMBOL of selected ThingType. """
1465 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1467 print("Ignoring: Argument must be single character.")
1471 def command_ttcorpseid(str_int):
1472 """Set TT_CORPSE_ID of selected ThingType."""
1473 val = integer_test(str_int, 0, 255)
1475 if val in world_db["ThingTypes"]:
1476 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1478 print("Ignoring: Corpse ID belongs to no known ThignType.")
1481 def command_taid(id_string):
1482 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1484 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1486 id = id_setter(id_string, "ThingActions", command_taid, True)
1488 world_db["ThingActions"][id] = {
1494 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1497 @test_ThingAction_id
1498 def command_taname(name):
1499 """Set TA_NAME of selected ThingAction.
1501 The name must match a valid thing action function. If after the name
1502 setting no ThingAction with name "wait" remains, call set_world_inactive().
1504 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1505 or name == "pick_up":
1506 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1507 if 1 == world_db["WORLD_ACTIVE"]:
1508 wait_defined = False
1509 for id in world_db["ThingActions"]:
1510 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1513 if not wait_defined:
1514 set_world_inactive()
1516 print("Ignoring: Invalid action name.")
1517 # In contrast to the original,naming won't map a function to a ThingAction.
1521 """Call ai() on player Thing, then turn_over()."""
1522 ai(world_db["Things"][0])
1526 """Commands database.
1528 Map command start tokens to ([0]) number of expected command arguments, ([1])
1529 the command's meta-ness (i.e. is it to be written to the record file, is it to
1530 be ignored in replay mode if read from server input file), and ([2]) a function
1534 "QUIT": (0, True, command_quit),
1535 "PING": (0, True, command_ping),
1536 "THINGS_HERE": (2, True, command_thingshere),
1537 "MAKE_WORLD": (1, False, command_makeworld),
1538 "SEED_MAP": (1, False, command_seedmap),
1539 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1540 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1541 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1542 "MAP_LENGTH": (1, False, command_maplength),
1543 "WORLD_ACTIVE": (1, False, command_worldactive),
1544 "TA_ID": (1, False, command_taid),
1545 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1546 "TA_NAME": (1, False, command_taname),
1547 "TT_ID": (1, False, command_ttid),
1548 "TT_NAME": (1, False, command_ttname),
1549 "TT_SYMBOL": (1, False, command_ttsymbol),
1550 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1551 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1553 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1555 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1557 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1558 "T_ID": (1, False, command_tid),
1559 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1560 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1561 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1562 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1563 "T_COMMAND": (1, False, command_tcommand),
1564 "T_TYPE": (1, False, command_ttype),
1565 "T_CARRIES": (1, False, command_tcarries),
1566 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1567 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1568 "T_MEMTHING": (3, False, command_tmemthing),
1569 "T_POSY": (1, False, setter_tpos("Y")),
1570 "T_POSX": (1, False, setter_tpos("X")),
1571 "wait": (0, False, play_commander("wait")),
1572 "move": (1, False, play_commander("move")),
1573 "pick_up": (0, False, play_commander("pick_up")),
1574 "drop": (1, False, play_commander("drop", True)),
1575 "use": (1, False, play_commander("use", True)),
1576 "ai": (0, False, command_ai)
1580 """World state database. With sane default values. (Randomness is in rand.)"""
1592 """Mapping of direction names to internal direction chars."""
1593 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1594 "west": "s", "north-west": "w", "north-east": "e"}
1596 """File IO database."""
1598 "path_save": "save",
1599 "path_record": "record",
1600 "path_worldconf": "confserver/world",
1601 "path_server": "server/",
1602 "path_in": "server/in",
1603 "path_out": "server/out",
1604 "path_worldstate": "server/worldstate",
1605 "tmp_suffix": "_tmp",
1606 "kicked_by_rival": False,
1607 "worldstate_updateable": False
1612 libpr = prep_library()
1613 rand = RandomnessIO()
1614 opts = parse_command_line_arguments()
1616 if None != opts.replay:
1620 except SystemExit as exit:
1621 print("ABORTING: " + exit.args[0])
1623 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")