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 os.makedirs(io_db["path_server"], exist_ok=True)
84 io_db["file_out"] = open(io_db["path_out"], "w")
85 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
86 if os.access(io_db["path_in"], os.F_OK):
87 os.remove(io_db["path_in"])
88 io_db["file_in"] = open(io_db["path_in"], "w")
89 io_db["file_in"].close()
90 io_db["file_in"] = open(io_db["path_in"], "r")
91 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
92 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
95 def cleanup_server_io():
96 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
97 def helper(file_key, path_key):
99 io_db[file_key].close()
100 if not io_db["kicked_by_rival"] \
101 and os.access(io_db[path_key], os.F_OK):
102 os.remove(io_db[path_key])
103 helper("file_out", "path_out")
104 helper("file_in", "path_in")
105 helper("file_worldstate", "path_worldstate")
106 if "file_record" in io_db:
107 io_db["file_record"].close()
110 def obey(command, prefix, replay=False, do_record=False):
111 """Call function from commands_db mapped to command's first token.
113 Tokenize command string with shlex.split(comments=True). If replay is set,
114 a non-meta command from the commands_db merely triggers obey() on the next
115 command from the records file. If not, non-meta commands set
116 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
117 do_record is set, are recorded via record(), and save_world() is called if
118 15 seconds have passed since the last time it was called. The prefix string
119 is inserted into the server's input message between its beginning 'input '
120 & ':'. All activity is preceded by a server_test() call.
123 print("input " + prefix + ": " + command)
125 tokens = shlex.split(command, comments=True)
126 except ValueError as err:
127 print("Can't tokenize command string: " + str(err) + ".")
129 if len(tokens) > 0 and tokens[0] in commands_db \
130 and len(tokens) == commands_db[tokens[0]][0] + 1:
131 if commands_db[tokens[0]][1]:
132 commands_db[tokens[0]][2](*tokens[1:])
134 print("Due to replay mode, reading command as 'go on in record'.")
135 line = io_db["file_record"].readline()
137 obey(line.rstrip(), io_db["file_record"].prefix
138 + str(io_db["file_record"].line_n))
139 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
141 print("Reached end of record file.")
143 commands_db[tokens[0]][2](*tokens[1:])
146 if time.time() > io_db["save_wait"] + 15:
148 io_db["save_wait"] = time.time()
149 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
150 elif 0 != len(tokens):
151 print("Invalid command/argument, or bad number of tokens.")
154 def atomic_write(path, text, do_append=False):
155 """Atomic write of text to file at path, appended if do_append is set."""
156 path_tmp = path + io_db["tmp_suffix"]
160 if os.access(path, os.F_OK):
161 shutil.copyfile(path, path_tmp)
162 file = open(path_tmp, mode)
163 strong_write(file, text)
165 if os.access(path, os.F_OK):
167 os.rename(path_tmp, path)
171 """Append command string plus newline to record file. (Atomic.)"""
172 # This misses some optimizations from the original record(), namely only
173 # finishing the atomic write with expensive flush() and fsync() every 15
174 # seconds unless explicitely forced. Implement as needed.
175 atomic_write(io_db["path_record"], command + "\n", do_append=True)
179 """Save all commands needed to reconstruct current world state."""
180 # TODO: Misses same optimizations as record() from the original record().
183 string = string.replace("\u005C", '\u005C\u005C')
184 return '"' + string.replace('"', '\u005C"') + '"'
189 if world_db["Things"][id][key]:
190 map = world_db["Things"][id][key]
191 length = world_db["MAP_LENGTH"]
192 for i in range(length):
193 line = map[i * length:(i * length) + length].decode()
194 string = string + key + " " + str(i) + " " + quote(line) \
201 for memthing in world_db["Things"][id]["T_MEMTHING"]:
202 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
203 str(memthing[1]) + " " + str(memthing[2]) + "\n"
206 def helper(category, id_string, special_keys={}):
208 for id in world_db[category]:
209 string = string + id_string + " " + str(id) + "\n"
210 for key in world_db[category][id]:
211 if not key in special_keys:
212 x = world_db[category][id][key]
213 argument = quote(x) if str == type(x) else str(x)
214 string = string + key + " " + argument + "\n"
215 elif special_keys[key]:
216 string = string + special_keys[key](id)
221 if dict != type(world_db[key]) and key != "MAP" and \
222 key != "WORLD_ACTIVE" and key != "SEED_MAP":
223 string = string + key + " " + str(world_db[key]) + "\n"
224 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
225 string = string + helper("ThingActions", "TA_ID")
226 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
227 for id in world_db["ThingTypes"]:
228 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
229 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
230 string = string + helper("Things", "T_ID",
231 {"T_CARRIES": False, "carried": False,
232 "T_MEMMAP": mapsetter("T_MEMMAP"),
233 "T_MEMTHING": memthing, "fovmap": False,
234 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
235 for id in world_db["Things"]:
236 if [] != world_db["Things"][id]["T_CARRIES"]:
237 string = string + "T_ID " + str(id) + "\n"
238 for carried_id in world_db["Things"][id]["T_CARRIES"]:
239 string = string + "T_CARRIES " + str(carried_id) + "\n"
240 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
241 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
242 atomic_write(io_db["path_save"], string)
245 def obey_lines_in_file(path, name, do_record=False):
246 """Call obey() on each line of path's file, use name in input prefix."""
247 file = open(path, "r")
249 for line in file.readlines():
250 obey(line.rstrip(), name + "file line " + str(line_n),
256 def parse_command_line_arguments():
257 """Return settings values read from command line arguments."""
258 parser = argparse.ArgumentParser()
259 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
261 opts, unknown = parser.parse_known_args()
266 """Ensure valid server out file belonging to current process.
268 This is done by comparing io_db["teststring"] to what's found at the start
269 of the current file at io_db["path_out"]. On failure, set
270 io_db["kicked_by_rival"] and raise SystemExit.
272 if not os.access(io_db["path_out"], os.F_OK):
273 raise SystemExit("Server output file has disappeared.")
274 file = open(io_db["path_out"], "r")
275 test = file.readline().rstrip("\n")
277 if test != io_db["teststring"]:
278 io_db["kicked_by_rival"] = True
279 msg = "Server test string in server output file does not match. This" \
280 " indicates that the current server process has been " \
281 "superseded by another one."
282 raise SystemExit(msg)
286 """Return next newline-delimited command from server in file.
288 Keep building return string until a newline is encountered. Pause between
289 unsuccessful reads, and after too much waiting, run server_test().
291 wait_on_fail = 0.03333
296 add = io_db["file_in"].readline()
298 command = command + add
299 if len(command) > 0 and "\n" == command[-1]:
300 command = command[:-1]
303 time.sleep(wait_on_fail)
304 if now + max_wait < time.time():
310 def try_worldstate_update():
311 """Write worldstate file if io_db["worldstate_updateable"] is set."""
312 if io_db["worldstate_updateable"]:
314 def draw_visible_Things(map, run):
315 for id in world_db["Things"]:
316 type = world_db["Things"][id]["T_TYPE"]
317 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
318 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
319 if (0 == run and not consumable and not alive) \
320 or (1 == run and consumable and not alive) \
321 or (2 == run and alive):
322 y = world_db["Things"][id]["T_POSY"]
323 x = world_db["Things"][id]["T_POSX"]
324 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
325 if 'v' == chr(fovflag):
326 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
327 map[(y * length) + x] = ord(c)
329 def write_map(string, map):
330 for i in range(length):
331 line = map[i * length:(i * length) + length].decode()
332 string = string + line + "\n"
336 if [] == world_db["Things"][0]["T_CARRIES"]:
337 inventory = "(none)\n"
339 for id in world_db["Things"][0]["T_CARRIES"]:
340 type_id = world_db["Things"][id]["T_TYPE"]
341 name = world_db["ThingTypes"][type_id]["TT_NAME"]
342 inventory = inventory + name + "\n"
343 string = str(world_db["TURN"]) + "\n" + \
344 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
345 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
346 inventory + "%\n" + \
347 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
348 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
349 str(world_db["MAP_LENGTH"]) + "\n"
350 length = world_db["MAP_LENGTH"]
351 fov = bytearray(b' ' * (length ** 2))
352 for pos in range(length ** 2):
353 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
354 fov[pos] = world_db["MAP"][pos]
356 draw_visible_Things(fov, i)
357 string = write_map(string, fov)
358 mem = world_db["Things"][0]["T_MEMMAP"][:]
360 for mt in world_db["Things"][0]["T_MEMTHING"]:
361 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
362 if (i == 0 and not consumable) or (i == 1 and consumable):
363 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
364 mem[(mt[1] * length) + mt[2]] = ord(c)
365 string = write_map(string, mem)
366 atomic_write(io_db["path_worldstate"], string)
367 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
368 io_db["worldstate_updateable"] = False
372 """Replay game from record file.
374 Use opts.replay as breakpoint turn to which to replay automatically before
375 switching to manual input by non-meta commands in server input file
376 triggering further reads of record file. Ensure opts.replay is at least 1.
377 Run try_worldstate_update() before each interactive obey()/read_command().
381 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
382 " (if so late a turn is to be found).")
383 if not os.access(io_db["path_record"], os.F_OK):
384 raise SystemExit("No record file found to replay.")
385 io_db["file_record"] = open(io_db["path_record"], "r")
386 io_db["file_record"].prefix = "record file line "
387 io_db["file_record"].line_n = 1
388 while world_db["TURN"] < opts.replay:
389 line = io_db["file_record"].readline()
392 obey(line.rstrip(), io_db["file_record"].prefix
393 + str(io_db["file_record"].line_n))
394 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
396 try_worldstate_update()
397 obey(read_command(), "in file", replay=True)
401 """Play game by server input file commands. Before, load save file found.
403 If no save file is found, a new world is generated from the commands in the
404 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
405 command and all that follow via the server input file. Run
406 try_worldstate_update() before each interactive obey()/read_command().
408 if os.access(io_db["path_save"], os.F_OK):
409 obey_lines_in_file(io_db["path_save"], "save")
411 if not os.access(io_db["path_worldconf"], os.F_OK):
412 msg = "No world config file from which to start a new world."
413 raise SystemExit(msg)
414 obey_lines_in_file(io_db["path_worldconf"], "world config ",
416 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
418 try_worldstate_update()
419 obey(read_command(), "in file", do_record=True)
423 """(Re-)make island map.
425 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
426 start with one land cell in the middle, then go into cycle of repeatedly
427 selecting a random sea cell and transforming it into land if it is neighbor
428 to land. The cycle ends when a land cell is due to be created at the map's
429 border. Then put some trees on the map (TODO: more precise algorithm desc).
431 def is_neighbor(coordinates, type):
434 length = world_db["MAP_LENGTH"]
436 diag_west = x + (ind > 0)
437 diag_east = x + (ind < (length - 1))
438 pos = (y * length) + x
439 if (y > 0 and diag_east
440 and type == chr(world_db["MAP"][pos - length + ind])) \
442 and type == chr(world_db["MAP"][pos + 1])) \
443 or (y < (length - 1) and diag_east
444 and type == chr(world_db["MAP"][pos + length + ind])) \
445 or (y > 0 and diag_west
446 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
448 and type == chr(world_db["MAP"][pos - 1])) \
449 or (y < (length - 1) and diag_west
450 and type == chr(world_db["MAP"][pos + length - (not ind)])):
453 store_seed = rand.seed
454 rand.seed = world_db["SEED_MAP"]
455 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
456 length = world_db["MAP_LENGTH"]
457 add_half_width = (not (length % 2)) * int(length / 2)
458 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
460 y = rand.next() % length
461 x = rand.next() % length
462 pos = (y * length) + x
463 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
464 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
466 world_db["MAP"][pos] = ord(".")
467 n_trees = int((length ** 2) / 16)
469 while (i_trees <= n_trees):
470 single_allowed = rand.next() % 32
471 y = rand.next() % length
472 x = rand.next() % length
473 pos = (y * length) + x
474 if "." == chr(world_db["MAP"][pos]) \
475 and ((not single_allowed) or is_neighbor((y, x), "X")):
476 world_db["MAP"][pos] = ord("X")
478 rand.seed = store_seed
479 # This all-too-precise replica of the original C code misses iter_limit().
482 def update_map_memory(t, age_map=True):
483 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
484 if not t["T_MEMMAP"]:
485 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
486 if not t["T_MEMDEPTHMAP"]:
487 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
488 for pos in range(world_db["MAP_LENGTH"] ** 2):
489 if "v" == chr(t["fovmap"][pos]):
490 t["T_MEMDEPTHMAP"][pos] = ord("0")
491 if " " == chr(t["T_MEMMAP"][pos]):
492 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
494 if age_map and ord('0') <= t["T_MEMDEPTHMAP"][pos] \
495 and ord('9') > t["T_MEMDEPTHMAP"][pos] \
496 and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)):
497 t["T_MEMDEPTHMAP"][pos] += 1
498 for mt in [mt for mt in t["T_MEMTHING"]
499 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
501 t["T_MEMTHING"].remove(mt)
502 for id in [id for id in world_db["Things"]
503 if not world_db["Things"][id]["carried"]]:
504 type = world_db["Things"][id]["T_TYPE"]
505 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
506 y = world_db["Things"][id]["T_POSY"]
507 x = world_db["Things"][id]["T_POSX"]
508 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
509 t["T_MEMTHING"].append((type, y, x))
512 def set_world_inactive():
513 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
515 if os.access(io_db["path_worldstate"], os.F_OK):
516 os.remove(io_db["path_worldstate"])
517 world_db["WORLD_ACTIVE"] = 0
520 def integer_test(val_string, min, max):
521 """Return val_string if possible integer >= min and <= max, else None."""
523 val = int(val_string)
524 if val < min or val > max:
528 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
533 def setter(category, key, min, max):
534 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
537 val = integer_test(val_string, min, max)
541 if category == "Thing":
542 id_store = command_tid
543 decorator = test_Thing_id
544 elif category == "ThingType":
545 id_store = command_ttid
546 decorator = test_ThingType_id
547 elif category == "ThingAction":
548 id_store = command_taid
549 decorator = test_ThingAction_id
553 val = integer_test(val_string, min, max)
555 world_db[category + "s"][id_store.id][key] = val
559 def build_fov_map(t):
560 """Build Thing's FOV map."""
561 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
562 maptype = ctypes.c_char * len(world_db["MAP"])
563 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
564 maptype.from_buffer(t["fovmap"]),
565 maptype.from_buffer(world_db["MAP"]))
567 raise RuntimeError("Malloc error in build_fov_Map().")
570 def decrement_lifepoints(t):
571 """Decrement t's lifepoints by 1, and if to zero, corpse it.
573 If t is the player avatar, only blank its fovmap, so that the client may
574 still display memory data. On non-player things, erase fovmap and memory.
576 t["T_LIFEPOINTS"] -= 1
577 if 0 == t["T_LIFEPOINTS"]:
578 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
579 if world_db["Things"][0] == t:
580 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
581 strong_write(io_db["file_out"], "LOG You die.\n")
584 t["T_MEMMAP"] = False
585 t["T_MEMDEPTHMAP"] = False
587 strong_write(io_db["file_out"], "LOG It dies.\n")
590 def mv_yx_in_dir_legal(dir, y, x):
591 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
592 dir_c = dir.encode("ascii")[0]
593 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
595 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
596 return (test, libpr.result_y(), libpr.result_x())
600 """Make t do nothing (but loudly, if player avatar)."""
601 if t == world_db["Things"][0]:
602 strong_write(io_db["file_out"], "LOG You wait.\n")
606 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
608 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
609 t["T_POSY"], t["T_POSX"])
610 if 1 == move_result[0]:
611 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
612 passable = "." == chr(world_db["MAP"][pos])
613 hitted = [id for id in world_db["Things"]
614 if world_db["Things"][id] != t
615 if world_db["Things"][id]["T_LIFEPOINTS"]
616 if world_db["Things"][id]["T_POSY"] == move_result[1]
617 if world_db["Things"][id]["T_POSX"] == move_result[2]]
620 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
621 hitter = "You" if t == world_db["Things"][0] else hitter_name
622 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
623 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
624 hitted = "you" if hit_id == 0 else hitted_name
625 verb = " wound " if hitter == "You" else " wounds "
626 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
628 decrement_lifepoints(world_db["Things"][hit_id])
630 dir = [dir for dir in directions_db
631 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
633 t["T_POSY"] = move_result[1]
634 t["T_POSX"] = move_result[2]
635 for id in t["T_CARRIES"]:
636 world_db["Things"][id]["T_POSY"] = move_result[1]
637 world_db["Things"][id]["T_POSX"] = move_result[2]
639 if t == world_db["Things"][0]:
640 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
641 elif t == world_db["Things"][0]:
642 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
645 def actor_pick_up(t):
646 """Make t pick up (topmost?) Thing from ground into inventory."""
647 # Topmostness is actually not defined so far. Picks Thing with highest ID.
648 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
649 if not world_db["Things"][id]["carried"]
650 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
651 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
657 world_db["Things"][highest_id]["carried"] = True
658 t["T_CARRIES"].append(highest_id)
659 if t == world_db["Things"][0]:
660 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
661 elif t == world_db["Things"][0]:
662 err = "You try to pick up an object, but there is none."
663 strong_write(io_db["file_out"], "LOG " + err + "\n")
667 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
668 # TODO: Handle case where T_ARGUMENT matches nothing.
669 if len(t["T_CARRIES"]):
670 id = t["T_CARRIES"][t["T_ARGUMENT"]]
671 t["T_CARRIES"].remove(id)
672 world_db["Things"][id]["carried"] = False
673 if t == world_db["Things"][0]:
674 strong_write(io_db["file_out"], "LOG You drop an object.\n")
675 elif t == world_db["Things"][0]:
676 err = "You try to drop an object, but you own none."
677 strong_write(io_db["file_out"], "LOG " + err + "\n")
681 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
682 # TODO: Handle case where T_ARGUMENT matches nothing.
683 if len(t["T_CARRIES"]):
684 id = t["T_CARRIES"][t["T_ARGUMENT"]]
685 type = world_db["Things"][id]["T_TYPE"]
686 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
687 t["T_CARRIES"].remove(id)
688 del world_db["Things"][id]
689 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
690 if t == world_db["Things"][0]:
691 strong_write(io_db["file_out"],
692 "LOG You consume this object.\n")
693 elif t == world_db["Things"][0]:
694 strong_write(io_db["file_out"],
695 "LOG You try to use this object, but fail.\n")
696 elif t == world_db["Things"][0]:
697 strong_write(io_db["file_out"],
698 "LOG You try to use an object, but you own none.\n")
701 def thingproliferation(t):
702 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
704 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
705 passable and not be inhabited by a Thing of the same type, or, if Thing is
706 animate, any other animate Thing. If there are several map cell candidates,
707 one is selected randomly.
709 def test_cell(t, y, x):
710 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
711 for id in [id for id in world_db["Things"]
712 if y == world_db["Things"][id]["T_POSY"]
713 if x == world_db["Things"][id]["T_POSX"]
714 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
715 or (t["T_LIFEPOINTS"] and
716 world_db["Things"][id]["T_LIFEPOINTS"])]:
720 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
721 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
723 for dir in [directions_db[key] for key in directions_db]:
724 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
725 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
726 candidates.append((mv_result[1], mv_result[2]))
728 i = rand.next() % len(candidates)
729 id = id_setter(-1, "Things")
730 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
731 world_db["Things"][id] = newT
735 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
737 On success, decrease satiation score by 32.
739 if t["T_SATIATION"] > 0 \
740 and t["T_LIFEPOINTS"] < \
741 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
742 and 0 == (rand.next() % 31) \
743 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
744 if world_db["ThingActions"][id]["TA_NAME"] ==
746 t["T_LIFEPOINTS"] += 1
747 t["T_SATIATION"] -= 32
748 if t == world_db["Things"][0]:
749 strong_write(io_db["file_out"], "LOG You heal.\n")
751 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
752 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
756 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
757 if t["T_SATIATION"] > -32768:
758 t["T_SATIATION"] -= 1
759 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
760 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
761 raise RuntimeError("A thing that should not hunger is hungering.")
762 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
763 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
764 if t == world_db["Things"][0]:
765 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
767 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
768 strong_write(io_db["file_out"], "LOG " + name +
769 " suffers from hunger.\n")
770 decrement_lifepoints(t)
773 def get_dir_to_target(t, filter):
774 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
776 The path-wise nearest target is chosen, via the shortest available path.
777 Target must not be t. On succcess, return positive value, else False.
779 "a": Thing in FOV is below a certain distance, animate, but of ThingType
780 that is not t's, and starts out weaker than t is; build path as
781 avoiding things of t's ThingType
782 "f": neighbor cell (not inhabited by any animate Thing) further away from
783 animate Thing not further than x steps away and in FOV and of a
784 ThingType that is not t's, and starts out stronger or as strong as t
785 is currently; or (cornered), if no such flight cell, but Thing of
786 above criteria is too near,1 a cell closer to it, or, if less near,
788 "c": Thing in memorized map is consumable
789 "s": memory map cell with greatest-reachable degree of unexploredness
792 def set_map_score(pos, score):
793 test = libpr.set_map_score(pos, score)
795 raise RuntimeError("No score map allocated for set_map_score().")
797 def get_map_score(pos):
798 result = libpr.get_map_score(pos)
800 raise RuntimeError("No score map allocated for get_map_score().")
804 if t["fovmap"] and ("a" == filter or "f" == filter):
805 for id in world_db["Things"]:
806 Thing = world_db["Things"][id]
807 if Thing != t and Thing["T_LIFEPOINTS"] and \
808 t["T_TYPE"] != Thing["T_TYPE"] and \
809 'v' == chr(t["fovmap"][(Thing["T_POSY"]
810 * world_db["MAP_LENGTH"])
812 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
813 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
815 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
818 elif t["T_MEMMAP"] and "c" == filter:
819 for mt in t["T_MEMTHING"]:
820 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
822 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
826 def init_score_map():
827 test = libpr.init_score_map()
829 raise RuntimeError("Malloc error in init_score_map().")
830 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
831 if '.' == chr(t["T_MEMMAP"][i])]:
832 set_map_score(i, 65535 - 1)
834 for id in world_db["Things"]:
835 Thing = world_db["Things"][id]
836 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
838 if t != Thing and Thing["T_LIFEPOINTS"] and \
839 t["T_TYPE"] != Thing["T_TYPE"] and \
840 'v' == chr(t["fovmap"][pos]) and \
841 t["T_LIFEPOINTS"] > \
842 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
843 set_map_score(pos, 0)
844 elif t["T_TYPE"] == Thing["T_TYPE"]:
845 set_map_score(pos, 65535)
847 for id in [id for id in world_db["Things"]
848 if world_db["Things"][id]["T_LIFEPOINTS"]]:
849 Thing = world_db["Things"][id]
850 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
852 if t["T_TYPE"] != Thing["T_TYPE"] and \
853 'v' == chr(t["fovmap"][pos]) and \
854 t["T_LIFEPOINTS"] <= \
855 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
856 set_map_score(pos, 0)
858 for mt in [mt for mt in t["T_MEMTHING"]
859 if ' ' != chr(t["T_MEMMAP"][mt[1]
860 * world_db["MAP_LENGTH"]
862 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
863 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
865 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
866 if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
869 def rand_target_dir(neighbors, cmp, dirs):
872 for i in range(len(dirs)):
873 if cmp == neighbors[i]:
874 candidates.append(dirs[i])
876 return candidates[rand.next() % n_candidates] if n_candidates else 0
878 def get_neighbor_scores(dirs, eye_pos):
880 if libpr.ready_neighbor_scores(eye_pos):
881 raise RuntimeError("No score map allocated for " +
882 "ready_neighbor_scores.()")
883 for i in range(len(dirs)):
884 scores.append(libpr.get_neighbor_score(i))
887 def get_dir_from_neighbors():
888 dir_to_target = False
890 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
891 neighbors = get_neighbor_scores(dirs, eye_pos)
893 inhabited = [world_db["Things"][id]["T_POSY"]
894 * world_db["MAP_LENGTH"]
895 + world_db["Things"][id]["T_POSX"]
896 for id in world_db["Things"]
897 if world_db["Things"][id]["T_LIFEPOINTS"]]
898 for i in range(len(dirs)):
899 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
900 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
902 for pos in [pos for pos in inhabited if pos == pos_cmp]:
905 minmax_start = 0 if "f" == filter else 65535 - 1
906 minmax_neighbor = minmax_start
907 for i in range(len(dirs)):
908 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
909 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
910 or ("f" != filter and minmax_neighbor > neighbors[i]):
911 minmax_neighbor = neighbors[i]
912 if minmax_neighbor != minmax_start:
913 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
915 if not dir_to_target:
916 if 1 == get_map_score(eye_pos):
917 dir_to_target = rand_target_dir(neighbors, 0, dirs)
918 elif 3 >= get_map_score(eye_pos):
919 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
921 world_db["ThingActions"][id]["TA_NAME"]
924 elif dir_to_target and 3 < get_map_score(eye_pos):
926 elif "a" == filter and 10 <= get_map_score(eye_pos):
930 dir_to_target = False
932 run_i = 9 + 1 if "s" == filter else 1
933 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
936 mem_depth_c = b'9' if b' ' == mem_depth_c \
937 else bytes([mem_depth_c[0] - 1])
938 if libpr.dijkstra_map():
939 raise RuntimeError("No score map allocated for dijkstra_map().")
940 dir_to_target = get_dir_from_neighbors()
941 libpr.free_score_map()
942 if dir_to_target and str == type(dir_to_target):
943 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
944 if world_db["ThingActions"][id]["TA_NAME"]
946 t["T_ARGUMENT"] = ord(dir_to_target)
950 def standing_on_consumable(t):
951 """Return True/False whether t is standing on a consumable."""
952 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
953 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
954 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
955 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
961 def get_inventory_slot_to_consume(t):
962 """Return slot Id of strongest consumable in t's inventory, else -1."""
963 cmp_consumability = 0
966 for id in t["T_CARRIES"]:
967 type = world_db["Things"][id]["T_TYPE"]
968 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
969 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
976 """Determine next command/argment for actor t via AI algorithms.
978 AI will look for, and move towards, enemies (animate Things not of their
979 own ThingType); if they see none, they will consume consumables in their
980 inventory; if there are none, they will pick up what they stand on if they
981 stand on consumables; if they stand on none, they will move towards the
982 next consumable they see or remember on the map; if they see or remember
983 none, they will explore parts of the map unseen since ever or for at least
984 one turn; if there is nothing to explore, they will simply wait.
986 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
987 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
988 if not get_dir_to_target(t, "f"):
989 sel = get_inventory_slot_to_consume(t)
991 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
992 if world_db["ThingActions"][id]["TA_NAME"]
994 t["T_ARGUMENT"] = sel
995 elif standing_on_consumable(t):
996 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
997 if world_db["ThingActions"][id]["TA_NAME"]
999 elif (not get_dir_to_target(t, "c")) and \
1000 (not get_dir_to_target(t, "a")):
1001 get_dir_to_target(t, "s")
1005 """Run game world and its inhabitants until new player input expected."""
1007 whilebreaker = False
1008 while world_db["Things"][0]["T_LIFEPOINTS"]:
1009 for id in [id for id in world_db["Things"]]: # Only what's from start!
1010 if not id in world_db["Things"] or \
1011 world_db["Things"][id]["carried"]: # May have been consumed or
1012 continue # picked up during turn …
1013 Thing = world_db["Things"][id]
1014 if Thing["T_LIFEPOINTS"]:
1015 if not Thing["T_COMMAND"]:
1016 update_map_memory(Thing)
1022 Thing["T_PROGRESS"] += 1
1023 taid = [a for a in world_db["ThingActions"]
1024 if a == Thing["T_COMMAND"]][0]
1025 ThingAction = world_db["ThingActions"][taid]
1026 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1027 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1028 Thing["T_COMMAND"] = 0
1029 Thing["T_PROGRESS"] = 0
1031 thingproliferation(Thing)
1034 world_db["TURN"] += 1
1037 def new_Thing(type, pos=(0, 0)):
1038 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1040 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1052 "T_MEMDEPTHMAP": False,
1055 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1056 build_fov_map(thing)
1060 def id_setter(id, category, id_store=False, start_at_1=False):
1061 """Set ID of object of category to manipulate ID unused? Create new one.
1063 The ID is stored as id_store.id (if id_store is set). If the integer of the
1064 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
1065 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
1066 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
1067 new object is created, otherwise the new object's ID.
1069 min = 0 if start_at_1 else -32768
1070 max = 255 if start_at_1 else 32767
1072 id = integer_test(id, min, max)
1074 if id in world_db[category]:
1079 if (start_at_1 and 0 == id) \
1080 or ((not start_at_1) and (id < 0 or id > 255)):
1084 if id not in world_db[category]:
1088 "No unused ID available to add to ID list.")
1096 """Send PONG line to server output file."""
1097 strong_write(io_db["file_out"], "PONG\n")
1101 """Abort server process."""
1103 raise SystemExit("received QUIT command")
1106 def command_thingshere(str_y, str_x):
1107 """Write to out file list of Things known to player at coordinate y, x."""
1108 if world_db["WORLD_ACTIVE"]:
1109 y = integer_test(str_y, 0, 255)
1110 x = integer_test(str_x, 0, 255)
1111 length = world_db["MAP_LENGTH"]
1112 if None != y and None != x and y < length and x < length:
1113 pos = (y * world_db["MAP_LENGTH"]) + x
1114 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1115 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1116 for id in world_db["Things"]:
1117 if y == world_db["Things"][id]["T_POSY"] \
1118 and x == world_db["Things"][id]["T_POSX"] \
1119 and not world_db["Things"][id]["carried"]:
1120 type = world_db["Things"][id]["T_TYPE"]
1121 name = world_db["ThingTypes"][type]["TT_NAME"]
1122 strong_write(io_db["file_out"], name + "\n")
1124 for mt in world_db["Things"][0]["T_MEMTHING"]:
1125 if y == mt[1] and x == mt[2]:
1126 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1127 strong_write(io_db["file_out"], name + "\n")
1128 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1130 print("Ignoring: Invalid map coordinates.")
1132 print("Ignoring: Command only works on existing worlds.")
1135 def play_commander(action, args=False):
1136 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1138 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1142 id = [x for x in world_db["ThingActions"]
1143 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1144 world_db["Things"][0]["T_COMMAND"] = id
1147 def set_command_and_argument_int(str_arg):
1148 val = integer_test(str_arg, 0, 255)
1150 world_db["Things"][0]["T_ARGUMENT"] = val
1153 def set_command_and_argument_movestring(str_arg):
1154 if str_arg in directions_db:
1155 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1158 print("Ignoring: Argument must be valid direction string.")
1160 if action == "move":
1161 return set_command_and_argument_movestring
1163 return set_command_and_argument_int
1168 def command_seedrandomness(seed_string):
1169 """Set rand seed to int(seed_string)."""
1170 val = integer_test(seed_string, 0, 4294967295)
1175 def command_seedmap(seed_string):
1176 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1177 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1181 def command_makeworld(seed_string):
1182 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1184 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1185 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1186 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1187 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1188 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1189 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1190 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1196 err = "Space to put thing on too hard to find. Map too small?"
1198 y = rand.next() % world_db["MAP_LENGTH"]
1199 x = rand.next() % world_db["MAP_LENGTH"]
1200 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1204 raise SystemExit(err)
1205 # Replica of C code, wrongly ignores animatedness of new Thing.
1206 pos_clear = (0 == len([id for id in world_db["Things"]
1207 if world_db["Things"][id]["T_LIFEPOINTS"]
1208 if world_db["Things"][id]["T_POSY"] == y
1209 if world_db["Things"][id]["T_POSX"] == x]))
1214 val = integer_test(seed_string, 0, 4294967295)
1218 world_db["SEED_MAP"] = val
1219 player_will_be_generated = False
1220 playertype = world_db["PLAYER_TYPE"]
1221 for ThingType in world_db["ThingTypes"]:
1222 if playertype == ThingType:
1223 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1224 player_will_be_generated = True
1226 if not player_will_be_generated:
1227 print("Ignoring beyond SEED_MAP: " +
1228 "No player type with start number >0 defined.")
1231 for ThingAction in world_db["ThingActions"]:
1232 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1235 print("Ignoring beyond SEED_MAP: " +
1236 "No thing action with name 'wait' defined.")
1238 world_db["Things"] = {}
1240 world_db["WORLD_ACTIVE"] = 1
1241 world_db["TURN"] = 1
1242 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1243 id = id_setter(-1, "Things")
1244 world_db["Things"][id] = new_Thing(playertype, free_pos())
1245 update_map_memory(world_db["Things"][0])
1246 for type in world_db["ThingTypes"]:
1247 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1248 if type != playertype:
1249 id = id_setter(-1, "Things")
1250 world_db["Things"][id] = new_Thing(type, free_pos())
1251 strong_write(io_db["file_out"], "NEW_WORLD\n")
1254 def command_maplength(maplength_string):
1255 """Redefine map length. Invalidate map, therefore lose all things on it."""
1256 val = integer_test(maplength_string, 1, 256)
1258 world_db["MAP_LENGTH"] = val
1259 set_world_inactive()
1260 world_db["Things"] = {}
1261 libpr.set_maplength(val)
1264 def command_worldactive(worldactive_string):
1265 """Toggle world_db["WORLD_ACTIVE"] if possible.
1267 An active world can always be set inactive. An inactive world can only be
1268 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1269 activation, rebuild all Things' FOVs, and the player's map memory.
1271 # In original version, map existence was also tested (unnecessarily?).
1272 val = integer_test(worldactive_string, 0, 1)
1274 if 0 != world_db["WORLD_ACTIVE"]:
1276 set_world_inactive()
1278 print("World already active.")
1279 elif 0 == world_db["WORLD_ACTIVE"]:
1281 for ThingAction in world_db["ThingActions"]:
1282 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1285 player_exists = False
1286 for Thing in world_db["Things"]:
1288 player_exists = True
1290 if wait_exists and player_exists:
1291 for id in world_db["Things"]:
1292 if world_db["Things"][id]["T_LIFEPOINTS"]:
1293 build_fov_map(world_db["Things"][id])
1295 update_map_memory(world_db["Things"][id], False)
1296 world_db["WORLD_ACTIVE"] = 1
1299 def test_for_id_maker(object, category):
1300 """Return decorator testing for object having "id" attribute."""
1303 if hasattr(object, "id"):
1306 print("Ignoring: No " + category +
1307 " defined to manipulate yet.")
1312 def command_tid(id_string):
1313 """Set ID of Thing to manipulate. ID unused? Create new one.
1315 Default new Thing's type to the first available ThingType, others: zero.
1317 id = id_setter(id_string, "Things", command_tid)
1319 if world_db["ThingTypes"] == {}:
1320 print("Ignoring: No ThingType to settle new Thing in.")
1322 type = list(world_db["ThingTypes"].keys())[0]
1323 world_db["Things"][id] = new_Thing(type)
1326 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1330 def command_tcommand(str_int):
1331 """Set T_COMMAND of selected Thing."""
1332 val = integer_test(str_int, 0, 255)
1334 if 0 == val or val in world_db["ThingActions"]:
1335 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1337 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1341 def command_ttype(str_int):
1342 """Set T_TYPE of selected Thing."""
1343 val = integer_test(str_int, 0, 255)
1345 if val in world_db["ThingTypes"]:
1346 world_db["Things"][command_tid.id]["T_TYPE"] = val
1348 print("Ignoring: ThingType ID belongs to no known ThingType.")
1352 def command_tcarries(str_int):
1353 """Append int(str_int) to T_CARRIES of selected Thing.
1355 The ID int(str_int) must not be of the selected Thing, and must belong to a
1356 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1358 val = integer_test(str_int, 0, 255)
1360 if val == command_tid.id:
1361 print("Ignoring: Thing cannot carry itself.")
1362 elif val in world_db["Things"] \
1363 and not world_db["Things"][val]["carried"]:
1364 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1365 world_db["Things"][val]["carried"] = True
1367 print("Ignoring: Thing not available for carrying.")
1368 # Note that the whole carrying structure is different from the C version:
1369 # Carried-ness is marked by a "carried" flag, not by Things containing
1370 # Things internally.
1374 def command_tmemthing(str_t, str_y, str_x):
1375 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1377 The type must fit to an existing ThingType, and the position into the map.
1379 type = integer_test(str_t, 0, 255)
1380 posy = integer_test(str_y, 0, 255)
1381 posx = integer_test(str_x, 0, 255)
1382 if None != type and None != posy and None != posx:
1383 if type not in world_db["ThingTypes"] \
1384 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1385 print("Ignoring: Illegal value for thing type or position.")
1387 memthing = (type, posy, posx)
1388 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1391 def setter_map(maptype):
1392 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1394 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1397 def helper(str_int, mapline):
1398 val = integer_test(str_int, 0, 255)
1400 if val >= world_db["MAP_LENGTH"]:
1401 print("Illegal value for map line number.")
1402 elif len(mapline) != world_db["MAP_LENGTH"]:
1403 print("Map line length is unequal map width.")
1405 length = world_db["MAP_LENGTH"]
1407 if not world_db["Things"][command_tid.id][maptype]:
1408 map = bytearray(b' ' * (length ** 2))
1410 map = world_db["Things"][command_tid.id][maptype]
1411 map[val * length:(val * length) + length] = mapline.encode()
1412 world_db["Things"][command_tid.id][maptype] = map
1416 def setter_tpos(axis):
1417 """Generate setter for T_POSX or T_POSY of selected Thing.
1419 If world is active, rebuilds animate things' fovmap, player's memory map.
1422 def helper(str_int):
1423 val = integer_test(str_int, 0, 255)
1425 if val < world_db["MAP_LENGTH"]:
1426 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1427 if world_db["WORLD_ACTIVE"] \
1428 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1429 build_fov_map(world_db["Things"][command_tid.id])
1430 if 0 == command_tid.id:
1431 update_map_memory(world_db["Things"][command_tid.id])
1433 print("Ignoring: Position is outside of map.")
1437 def command_ttid(id_string):
1438 """Set ID of ThingType to manipulate. ID unused? Create new one.
1440 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1442 id = id_setter(id_string, "ThingTypes", command_ttid)
1444 world_db["ThingTypes"][id] = {
1445 "TT_NAME": "(none)",
1448 "TT_PROLIFERATE": 0,
1449 "TT_START_NUMBER": 0,
1455 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1459 def command_ttname(name):
1460 """Set TT_NAME of selected ThingType."""
1461 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1465 def command_ttsymbol(char):
1466 """Set TT_SYMBOL of selected ThingType. """
1468 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1470 print("Ignoring: Argument must be single character.")
1474 def command_ttcorpseid(str_int):
1475 """Set TT_CORPSE_ID of selected ThingType."""
1476 val = integer_test(str_int, 0, 255)
1478 if val in world_db["ThingTypes"]:
1479 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1481 print("Ignoring: Corpse ID belongs to no known ThignType.")
1484 def command_taid(id_string):
1485 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1487 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1489 id = id_setter(id_string, "ThingActions", command_taid, True)
1491 world_db["ThingActions"][id] = {
1497 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1500 @test_ThingAction_id
1501 def command_taname(name):
1502 """Set TA_NAME of selected ThingAction.
1504 The name must match a valid thing action function. If after the name
1505 setting no ThingAction with name "wait" remains, call set_world_inactive().
1507 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1508 or name == "pick_up":
1509 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1510 if 1 == world_db["WORLD_ACTIVE"]:
1511 wait_defined = False
1512 for id in world_db["ThingActions"]:
1513 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1516 if not wait_defined:
1517 set_world_inactive()
1519 print("Ignoring: Invalid action name.")
1520 # In contrast to the original,naming won't map a function to a ThingAction.
1524 """Call ai() on player Thing, then turn_over()."""
1525 ai(world_db["Things"][0])
1529 """Commands database.
1531 Map command start tokens to ([0]) number of expected command arguments, ([1])
1532 the command's meta-ness (i.e. is it to be written to the record file, is it to
1533 be ignored in replay mode if read from server input file), and ([2]) a function
1537 "QUIT": (0, True, command_quit),
1538 "PING": (0, True, command_ping),
1539 "THINGS_HERE": (2, True, command_thingshere),
1540 "MAKE_WORLD": (1, False, command_makeworld),
1541 "SEED_MAP": (1, False, command_seedmap),
1542 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1543 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1544 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1545 "MAP_LENGTH": (1, False, command_maplength),
1546 "WORLD_ACTIVE": (1, False, command_worldactive),
1547 "TA_ID": (1, False, command_taid),
1548 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1549 "TA_NAME": (1, False, command_taname),
1550 "TT_ID": (1, False, command_ttid),
1551 "TT_NAME": (1, False, command_ttname),
1552 "TT_SYMBOL": (1, False, command_ttsymbol),
1553 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1554 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1556 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1558 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1560 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1561 "T_ID": (1, False, command_tid),
1562 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1563 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1564 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1565 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1566 "T_COMMAND": (1, False, command_tcommand),
1567 "T_TYPE": (1, False, command_ttype),
1568 "T_CARRIES": (1, False, command_tcarries),
1569 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1570 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1571 "T_MEMTHING": (3, False, command_tmemthing),
1572 "T_POSY": (1, False, setter_tpos("Y")),
1573 "T_POSX": (1, False, setter_tpos("X")),
1574 "wait": (0, False, play_commander("wait")),
1575 "move": (1, False, play_commander("move")),
1576 "pick_up": (0, False, play_commander("pick_up")),
1577 "drop": (1, False, play_commander("drop", True)),
1578 "use": (1, False, play_commander("use", True)),
1579 "ai": (0, False, command_ai)
1583 """World state database. With sane default values. (Randomness is in rand.)"""
1595 """Mapping of direction names to internal direction chars."""
1596 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1597 "west": "s", "north-west": "w", "north-east": "e"}
1599 """File IO database."""
1601 "path_save": "save",
1602 "path_record": "record",
1603 "path_worldconf": "confserver/world",
1604 "path_server": "server/",
1605 "path_in": "server/in",
1606 "path_out": "server/out",
1607 "path_worldstate": "server/worldstate",
1608 "tmp_suffix": "_tmp",
1609 "kicked_by_rival": False,
1610 "worldstate_updateable": False
1615 libpr = prep_library()
1616 rand = RandomnessIO()
1617 opts = parse_command_line_arguments()
1619 if None != opts.replay:
1623 except SystemExit as exit:
1624 print("ABORTING: " + exit.args[0])
1626 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")