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
48 def strong_write(file, string):
49 """Apply write(string), flush(), and os.fsync() to file."""
55 def setup_server_io():
56 """Fill IO files DB with proper file( path)s. Write process IO test string.
58 Ensure IO files directory at server/. Remove any old input file if found.
59 Set up new input file for reading, and new output file for writing. Start
60 output file with process hash line of format PID + " " + floated UNIX time
61 (io_db["teststring"]). Raise SystemExit if file is found at path of either
62 record or save file plus io_db["tmp_suffix"].
64 def detect_atomic_leftover(path, tmp_suffix):
65 path_tmp = path + tmp_suffix
66 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
67 "aborted previous attempt to write '" + path + "'. Aborting " \
68 "until matter is resolved by removing it from its current path."
69 if os.access(path_tmp, os.F_OK):
71 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
72 os.makedirs(io_db["path_server"], exist_ok=True)
73 io_db["file_out"] = open(io_db["path_out"], "w")
74 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
75 if os.access(io_db["path_in"], os.F_OK):
76 os.remove(io_db["path_in"])
77 io_db["file_in"] = open(io_db["path_in"], "w")
78 io_db["file_in"].close()
79 io_db["file_in"] = open(io_db["path_in"], "r")
80 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
81 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
84 def cleanup_server_io():
85 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
86 def helper(file_key, path_key):
88 io_db[file_key].close()
89 if not io_db["kicked_by_rival"] \
90 and os.access(io_db[path_key], os.F_OK):
91 os.remove(io_db[path_key])
92 helper("file_out", "path_out")
93 helper("file_in", "path_in")
94 helper("file_worldstate", "path_worldstate")
95 if "file_record" in io_db:
96 io_db["file_record"].close()
99 def obey(command, prefix, replay=False, do_record=False):
100 """Call function from commands_db mapped to command's first token.
102 Tokenize command string with shlex.split(comments=True). If replay is set,
103 a non-meta command from the commands_db merely triggers obey() on the next
104 command from the records file. If not, non-meta commands set
105 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
106 do_record is set, are recorded via record(), and save_world() is called.
107 The prefix string is inserted into the server's input message between its
108 beginning 'input ' & ':'. All activity is preceded by a server_test() call.
111 print("input " + prefix + ": " + command)
113 tokens = shlex.split(command, comments=True)
114 except ValueError as err:
115 print("Can't tokenize command string: " + str(err) + ".")
117 if len(tokens) > 0 and tokens[0] in commands_db \
118 and len(tokens) == commands_db[tokens[0]][0] + 1:
119 if commands_db[tokens[0]][1]:
120 commands_db[tokens[0]][2](*tokens[1:])
122 print("Due to replay mode, reading command as 'go on in record'.")
123 line = io_db["file_record"].readline()
125 obey(line.rstrip(), io_db["file_record"].prefix
126 + str(io_db["file_record"].line_n))
127 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
129 print("Reached end of record file.")
131 commands_db[tokens[0]][2](*tokens[1:])
135 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
136 elif 0 != len(tokens):
137 print("Invalid command/argument, or bad number of tokens.")
140 def atomic_write(path, text, do_append=False):
141 """Atomic write of text to file at path, appended if do_append is set."""
142 path_tmp = path + io_db["tmp_suffix"]
146 if os.access(path, os.F_OK):
147 shutil.copyfile(path, path_tmp)
148 file = open(path_tmp, mode)
149 strong_write(file, text)
151 if os.access(path, os.F_OK):
153 os.rename(path_tmp, path)
157 """Append command string plus newline to record file. (Atomic.)"""
158 # This misses some optimizations from the original record(), namely only
159 # finishing the atomic write with expensive flush() and fsync() every 15
160 # seconds unless explicitely forced. Implement as needed.
161 atomic_write(io_db["path_record"], command + "\n", do_append=True)
165 """Save all commands needed to reconstruct current world state."""
166 # TODO: Misses same optimizations as record() from the original record().
169 string = string.replace("\u005C", '\u005C\u005C')
170 return '"' + string.replace('"', '\u005C"') + '"'
175 if world_db["Things"][id][key]:
176 map = world_db["Things"][id][key]
177 length = world_db["MAP_LENGTH"]
178 for i in range(length):
179 line = map[i * length:(i * length) + length].decode()
180 string = string + key + " " + str(i) + " " + quote(line) \
187 for memthing in world_db["Things"][id]["T_MEMTHING"]:
188 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
189 str(memthing[1]) + " " + str(memthing[2]) + "\n"
192 def helper(category, id_string, special_keys={}):
194 for id in world_db[category]:
195 string = string + id_string + " " + str(id) + "\n"
196 for key in world_db[category][id]:
197 if not key in special_keys:
198 x = world_db[category][id][key]
199 argument = quote(x) if str == type(x) else str(x)
200 string = string + key + " " + argument + "\n"
201 elif special_keys[key]:
202 string = string + special_keys[key](id)
207 if dict != type(world_db[key]) and key != "MAP" and \
208 key != "WORLD_ACTIVE" and key != "SEED_MAP":
209 string = string + key + " " + str(world_db[key]) + "\n"
210 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
211 string = string + helper("ThingActions", "TA_ID")
212 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
213 for id in world_db["ThingTypes"]:
214 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
215 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
216 string = string + helper("Things", "T_ID",
217 {"T_CARRIES": False, "carried": False,
218 "T_MEMMAP": mapsetter("T_MEMMAP"),
219 "T_MEMTHING": memthing, "fovmap": False,
220 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
221 for id in world_db["Things"]:
222 if [] != world_db["Things"][id]["T_CARRIES"]:
223 string = string + "T_ID " + str(id) + "\n"
224 for carried_id in world_db["Things"][id]["T_CARRIES"]:
225 string = string + "T_CARRIES " + str(carried_id) + "\n"
226 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
227 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
228 atomic_write(io_db["path_save"], string)
231 def obey_lines_in_file(path, name, do_record=False):
232 """Call obey() on each line of path's file, use name in input prefix."""
233 file = open(path, "r")
235 for line in file.readlines():
236 obey(line.rstrip(), name + "file line " + str(line_n),
242 def parse_command_line_arguments():
243 """Return settings values read from command line arguments."""
244 parser = argparse.ArgumentParser()
245 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
247 opts, unknown = parser.parse_known_args()
252 """Ensure valid server out file belonging to current process.
254 This is done by comparing io_db["teststring"] to what's found at the start
255 of the current file at io_db["path_out"]. On failure, set
256 io_db["kicked_by_rival"] and raise SystemExit.
258 if not os.access(io_db["path_out"], os.F_OK):
259 raise SystemExit("Server output file has disappeared.")
260 file = open(io_db["path_out"], "r")
261 test = file.readline().rstrip("\n")
263 if test != io_db["teststring"]:
264 io_db["kicked_by_rival"] = True
265 msg = "Server test string in server output file does not match. This" \
266 " indicates that the current server process has been " \
267 "superseded by another one."
268 raise SystemExit(msg)
272 """Return next newline-delimited command from server in file.
274 Keep building return string until a newline is encountered. Pause between
275 unsuccessful reads, and after too much waiting, run server_test().
277 wait_on_fail = 0.03333
282 add = io_db["file_in"].readline()
284 command = command + add
285 if len(command) > 0 and "\n" == command[-1]:
286 command = command[:-1]
289 time.sleep(wait_on_fail)
290 if now + max_wait < time.time():
296 def try_worldstate_update():
297 """Write worldstate file if io_db["worldstate_updateable"] is set."""
298 if io_db["worldstate_updateable"]:
300 def draw_visible_Things(map, run):
301 for id in world_db["Things"]:
302 type = world_db["Things"][id]["T_TYPE"]
303 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
304 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
305 if (0 == run and not consumable and not alive) \
306 or (1 == run and consumable and not alive) \
307 or (2 == run and alive):
308 y = world_db["Things"][id]["T_POSY"]
309 x = world_db["Things"][id]["T_POSX"]
310 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
311 if 'v' == chr(fovflag):
312 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
313 map[(y * length) + x] = ord(c)
315 def write_map(string, map):
316 for i in range(length):
317 line = map[i * length:(i * length) + length].decode()
318 string = string + line + "\n"
322 if [] == world_db["Things"][0]["T_CARRIES"]:
323 inventory = "(none)\n"
325 for id in world_db["Things"][0]["T_CARRIES"]:
326 type_id = world_db["Things"][id]["T_TYPE"]
327 name = world_db["ThingTypes"][type_id]["TT_NAME"]
328 inventory = inventory + name + "\n"
329 string = str(world_db["TURN"]) + "\n" + \
330 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
331 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
332 inventory + "%\n" + \
333 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
334 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
335 str(world_db["MAP_LENGTH"]) + "\n"
336 length = world_db["MAP_LENGTH"]
337 fov = bytearray(b' ' * (length ** 2))
338 for pos in range(length ** 2):
339 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
340 fov[pos] = world_db["MAP"][pos]
342 draw_visible_Things(fov, i)
343 string = write_map(string, fov)
344 mem = world_db["Things"][0]["T_MEMMAP"][:]
346 for mt in world_db["Things"][0]["T_MEMTHING"]:
347 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
348 if (i == 0 and not consumable) or (i == 1 and consumable):
349 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
350 mem[(mt[1] * length) + mt[2]] = ord(c)
351 string = write_map(string, mem)
352 atomic_write(io_db["path_worldstate"], string)
353 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
354 io_db["worldstate_updateable"] = False
358 """Replay game from record file.
360 Use opts.replay as breakpoint turn to which to replay automatically before
361 switching to manual input by non-meta commands in server input file
362 triggering further reads of record file. Ensure opts.replay is at least 1.
363 Run try_worldstate_update() before each interactive obey()/read_command().
367 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
368 " (if so late a turn is to be found).")
369 if not os.access(io_db["path_record"], os.F_OK):
370 raise SystemExit("No record file found to replay.")
371 io_db["file_record"] = open(io_db["path_record"], "r")
372 io_db["file_record"].prefix = "record file line "
373 io_db["file_record"].line_n = 1
374 while world_db["TURN"] < opts.replay:
375 line = io_db["file_record"].readline()
378 obey(line.rstrip(), io_db["file_record"].prefix
379 + str(io_db["file_record"].line_n))
380 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
382 try_worldstate_update()
383 obey(read_command(), "in file", replay=True)
387 """Play game by server input file commands. Before, load save file found.
389 If no save file is found, a new world is generated from the commands in the
390 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
391 command and all that follow via the server input file. Run
392 try_worldstate_update() before each interactive obey()/read_command().
394 if os.access(io_db["path_save"], os.F_OK):
395 obey_lines_in_file(io_db["path_save"], "save")
397 if not os.access(io_db["path_worldconf"], os.F_OK):
398 msg = "No world config file from which to start a new world."
399 raise SystemExit(msg)
400 obey_lines_in_file(io_db["path_worldconf"], "world config ",
402 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
404 try_worldstate_update()
405 obey(read_command(), "in file", do_record=True)
409 """(Re-)make island map.
411 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
412 start with one land cell in the middle, then go into cycle of repeatedly
413 selecting a random sea cell and transforming it into land if it is neighbor
414 to land. The cycle ends when a land cell is due to be created at the map's
415 border. Then put some trees on the map (TODO: more precise algorithm desc).
417 def is_neighbor(coordinates, type):
420 length = world_db["MAP_LENGTH"]
422 diag_west = x + (ind > 0)
423 diag_east = x + (ind < (length - 1))
424 pos = (y * length) + x
425 if (y > 0 and diag_east
426 and type == chr(world_db["MAP"][pos - length + ind])) \
428 and type == chr(world_db["MAP"][pos + 1])) \
429 or (y < (length - 1) and diag_east
430 and type == chr(world_db["MAP"][pos + length + ind])) \
431 or (y > 0 and diag_west
432 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
434 and type == chr(world_db["MAP"][pos - 1])) \
435 or (y < (length - 1) and diag_west
436 and type == chr(world_db["MAP"][pos + length - (not ind)])):
439 store_seed = rand.seed
440 rand.seed = world_db["SEED_MAP"]
441 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
442 length = world_db["MAP_LENGTH"]
443 add_half_width = (not (length % 2)) * int(length / 2)
444 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
446 y = rand.next() % length
447 x = rand.next() % length
448 pos = (y * length) + x
449 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
450 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
452 world_db["MAP"][pos] = ord(".")
453 n_trees = int((length ** 2) / 16)
455 while (i_trees <= n_trees):
456 single_allowed = rand.next() % 32
457 y = rand.next() % length
458 x = rand.next() % length
459 pos = (y * length) + x
460 if "." == chr(world_db["MAP"][pos]) \
461 and ((not single_allowed) or is_neighbor((y, x), "X")):
462 world_db["MAP"][pos] = ord("X")
464 rand.seed = store_seed
465 # This all-too-precise replica of the original C code misses iter_limit().
468 def update_map_memory(t, age_map=True):
469 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
470 if not t["T_MEMMAP"]:
471 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
472 if not t["T_MEMDEPTHMAP"]:
473 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
474 for pos in range(world_db["MAP_LENGTH"] ** 2):
475 if "v" == chr(t["fovmap"][pos]):
476 t["T_MEMDEPTHMAP"][pos] = ord("0")
477 if " " == chr(t["T_MEMMAP"][pos]):
478 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
480 if age_map and ord('0') <= t["T_MEMDEPTHMAP"][pos] \
481 and ord('9') > t["T_MEMDEPTHMAP"][pos] \
482 and not rand.next() % (2 ** (t["T_MEMDEPTHMAP"][pos] - 48)):
483 t["T_MEMDEPTHMAP"][pos] += 1
484 for mt in [mt for mt in t["T_MEMTHING"]
485 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
487 t["T_MEMTHING"].remove(mt)
488 for id in [id for id in world_db["Things"]
489 if not world_db["Things"][id]["carried"]]:
490 type = world_db["Things"][id]["T_TYPE"]
491 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
492 y = world_db["Things"][id]["T_POSY"]
493 x = world_db["Things"][id]["T_POSX"]
494 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
495 t["T_MEMTHING"].append((type, y, x))
498 def set_world_inactive():
499 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
501 if os.access(io_db["path_worldstate"], os.F_OK):
502 os.remove(io_db["path_worldstate"])
503 world_db["WORLD_ACTIVE"] = 0
506 def integer_test(val_string, min, max):
507 """Return val_string if possible integer >= min and <= max, else None."""
509 val = int(val_string)
510 if val < min or val > max:
514 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
519 def setter(category, key, min, max):
520 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
523 val = integer_test(val_string, min, max)
527 if category == "Thing":
528 id_store = command_tid
529 decorator = test_Thing_id
530 elif category == "ThingType":
531 id_store = command_ttid
532 decorator = test_ThingType_id
533 elif category == "ThingAction":
534 id_store = command_taid
535 decorator = test_ThingAction_id
539 val = integer_test(val_string, min, max)
541 world_db[category + "s"][id_store.id][key] = val
545 def build_fov_map(t):
546 """Build Thing's FOV map."""
547 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
548 maptype = ctypes.c_char * len(world_db["MAP"])
549 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
550 maptype.from_buffer(t["fovmap"]),
551 maptype.from_buffer(world_db["MAP"]))
553 raise RuntimeError("Malloc error in build_fov_Map().")
556 def decrement_lifepoints(t):
557 """Decrement t's lifepoints by 1, and if to zero, corpse it.
559 If t is the player avatar, only blank its fovmap, so that the client may
560 still display memory data. On non-player things, erase fovmap and memory.
562 t["T_LIFEPOINTS"] -= 1
563 if 0 == t["T_LIFEPOINTS"]:
564 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
565 if world_db["Things"][0] == t:
566 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
567 strong_write(io_db["file_out"], "LOG You die.\n")
570 t["T_MEMMAP"] = False
571 t["T_MEMDEPTHMAP"] = False
573 strong_write(io_db["file_out"], "LOG It dies.\n")
576 def mv_yx_in_dir_legal(dir, y, x):
577 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
578 dir_c = dir.encode("ascii")[0]
579 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
581 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
582 return (test, libpr.result_y(), libpr.result_x())
586 """Make t do nothing (but loudly, if player avatar)."""
587 if t == world_db["Things"][0]:
588 strong_write(io_db["file_out"], "LOG You wait.\n")
592 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
594 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
595 t["T_POSY"], t["T_POSX"])
596 if 1 == move_result[0]:
597 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
598 passable = "." == chr(world_db["MAP"][pos])
599 hitted = [id for id in world_db["Things"]
600 if world_db["Things"][id] != t
601 if world_db["Things"][id]["T_LIFEPOINTS"]
602 if world_db["Things"][id]["T_POSY"] == move_result[1]
603 if world_db["Things"][id]["T_POSX"] == move_result[2]]
606 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
607 hitter = "You" if t == world_db["Things"][0] else hitter_name
608 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
609 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
610 hitted = "you" if hit_id == 0 else hitted_name
611 verb = " wound " if hitter == "You" else " wounds "
612 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
614 decrement_lifepoints(world_db["Things"][hit_id])
616 dir = [dir for dir in directions_db
617 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
619 t["T_POSY"] = move_result[1]
620 t["T_POSX"] = move_result[2]
621 for id in t["T_CARRIES"]:
622 world_db["Things"][id]["T_POSY"] = move_result[1]
623 world_db["Things"][id]["T_POSX"] = move_result[2]
625 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
627 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
630 def actor_pick_up(t):
631 """Make t pick up (topmost?) Thing from ground into inventory."""
632 # Topmostness is actually not defined so far. Picks Thing with highest ID.
633 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
634 if not world_db["Things"][id]["carried"]
635 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
636 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
642 world_db["Things"][highest_id]["carried"] = True
643 t["T_CARRIES"].append(highest_id)
644 if t == world_db["Things"][0]:
645 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
646 elif t == world_db["Things"][0]:
647 err = "You try to pick up an object, but there is none."
648 strong_write(io_db["file_out"], "LOG " + err + "\n")
652 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
653 # TODO: Handle case where T_ARGUMENT matches nothing.
654 if len(t["T_CARRIES"]):
655 id = t["T_CARRIES"][t["T_ARGUMENT"]]
656 t["T_CARRIES"].remove(id)
657 world_db["Things"][id]["carried"] = False
658 if t == world_db["Things"][0]:
659 strong_write(io_db["file_out"], "LOG You drop an object.\n")
660 elif t == world_db["Things"][0]:
661 err = "You try to drop an object, but you own none."
662 strong_write(io_db["file_out"], "LOG " + err + "\n")
666 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
667 # TODO: Handle case where T_ARGUMENT matches nothing.
668 if len(t["T_CARRIES"]):
669 id = t["T_CARRIES"][t["T_ARGUMENT"]]
670 type = world_db["Things"][id]["T_TYPE"]
671 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
672 t["T_CARRIES"].remove(id)
673 del world_db["Things"][id]
674 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
675 if t == world_db["Things"][0]:
676 strong_write(io_db["file_out"],
677 "LOG You consume this object.\n")
678 elif t == world_db["Things"][0]:
679 strong_write(io_db["file_out"],
680 "LOG You try to use this object, but fail.\n")
681 elif t == world_db["Things"][0]:
682 strong_write(io_db["file_out"],
683 "LOG You try to use an object, but you own none.\n")
686 def thingproliferation(t):
687 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
689 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
690 passable and not be inhabited by a Thing of the same type, or, if Thing is
691 animate, any other animate Thing. If there are several map cell candidates,
692 one is selected randomly.
694 def test_cell(t, y, x):
695 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
696 for id in [id for id in world_db["Things"]
697 if y == world_db["Things"][id]["T_POSY"]
698 if x == world_db["Things"][id]["T_POSX"]
699 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
700 or (t["T_LIFEPOINTS"] and
701 world_db["Things"][id]["T_LIFEPOINTS"])]:
705 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
706 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
708 for dir in [directions_db[key] for key in directions_db]:
709 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
710 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
711 candidates.append((mv_result[1], mv_result[2]))
713 i = rand.next() % len(candidates)
714 id = id_setter(-1, "Things")
715 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
716 world_db["Things"][id] = newT
720 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
722 On success, decrease satiation score by 32.
724 if t["T_SATIATION"] > 0 \
725 and t["T_LIFEPOINTS"] < \
726 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
727 and 0 == (rand.next() % 31) \
728 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
729 if world_db["ThingActions"][id]["TA_NAME"] ==
731 t["T_LIFEPOINTS"] += 1
732 t["T_SATIATION"] -= 32
733 if t == world_db["Things"][0]:
734 strong_write(io_db["file_out"], "LOG You heal.\n")
736 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
737 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
741 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
742 if t["T_SATIATION"] > -32768:
743 t["T_SATIATION"] -= 1
744 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
745 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
746 raise RuntimeError("A thing that should not hunger is hungering.")
747 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
748 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
749 if t == world_db["Things"][0]:
750 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
752 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
753 strong_write(io_db["file_out"], "LOG " + name +
754 " suffers from hunger.\n")
755 decrement_lifepoints(t)
758 def get_dir_to_nearest_target(t, c):
763 def standing_on_consumable(t):
764 """Return True/False whether t is standing on a consumable."""
765 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
766 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
767 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
768 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
774 def get_inventory_slot_to_consume(t):
775 """Return slot Id of strongest consumable in t's inventory, else -1."""
776 cmp_consumability = 0
779 for id in t["T_CARRIES"]:
780 type = world_db["Things"][id]["T_TYPE"]
781 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
782 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
789 """Determine next command/argment for actor t via AI algorithms.
791 AI will look for, and move towards, enemies (animate Things not of their
792 own ThingType); if they see none, they will consume consumables in their
793 inventory; if there are none, they will pick up what they stand on if they
794 stand on consumables; if they stand on none, they will move towards the
795 next consumable they see or remember on the map; if they see or remember
796 none, they will explore parts of the map unseen since ever or for at least
797 one turn; if there is nothing to explore, they will simply wait.
799 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
800 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
801 if not get_dir_to_nearest_target(t, "f"):
802 sel = get_inventory_slot_to_consume(t)
804 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
805 if world_db["ThingActions"][id]["TA_NAME"]
807 t["T_ARGUMENT"] = sel
808 elif standing_on_consumable(t):
809 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
810 if world_db["ThingActions"][id]["TA_NAME"]
812 elif (not get_dir_to_nearest_target(t, "c")) and \
813 (not get_dir_to_nearest_target(t, "a")):
814 get_dir_to_nearest_target(t, "s")
818 """Run game world and its inhabitants until new player input expected."""
821 while world_db["Things"][0]["T_LIFEPOINTS"]:
822 for id in [id for id in world_db["Things"]]:
823 if not id in world_db["Things"]: # Thing may have been consumed
824 continue # during turn …
825 Thing = world_db["Things"][id]
826 if Thing["T_LIFEPOINTS"]:
827 if not Thing["T_COMMAND"]:
828 update_map_memory(Thing)
833 Thing["T_COMMAND"] = 1
835 Thing["T_PROGRESS"] += 1
836 taid = [a for a in world_db["ThingActions"]
837 if a == Thing["T_COMMAND"]][0]
838 ThingAction = world_db["ThingActions"][taid]
839 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
840 eval("actor_" + ThingAction["TA_NAME"])(Thing)
841 Thing["T_COMMAND"] = 0
842 Thing["T_PROGRESS"] = 0
844 thingproliferation(Thing)
847 world_db["TURN"] += 1
850 def new_Thing(type, pos=(0, 0)):
851 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
853 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
865 "T_MEMDEPTHMAP": False,
868 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
873 def id_setter(id, category, id_store=False, start_at_1=False):
874 """Set ID of object of category to manipulate ID unused? Create new one.
876 The ID is stored as id_store.id (if id_store is set). If the integer of the
877 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
878 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
879 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
880 new object is created, otherwise the new object's ID.
882 min = 0 if start_at_1 else -32768
883 max = 255 if start_at_1 else 32767
885 id = integer_test(id, min, max)
887 if id in world_db[category]:
892 if (start_at_1 and 0 == id) \
893 or ((not start_at_1) and (id < 0 or id > 255)):
897 if id not in world_db[category]:
901 "No unused ID available to add to ID list.")
909 """Send PONG line to server output file."""
910 strong_write(io_db["file_out"], "PONG\n")
914 """Abort server process."""
915 raise SystemExit("received QUIT command")
918 def command_thingshere(str_y, str_x):
919 """Write to out file list of Things known to player at coordinate y, x."""
920 if world_db["WORLD_ACTIVE"]:
921 y = integer_test(str_y, 0, 255)
922 x = integer_test(str_x, 0, 255)
923 length = world_db["MAP_LENGTH"]
924 if None != y and None != x and y < length and x < length:
925 pos = (y * world_db["MAP_LENGTH"]) + x
926 strong_write(io_db["file_out"], "THINGS_HERE START\n")
927 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
928 for id in world_db["Things"]:
929 # write_thing_if_here()
930 if y == world_db["Things"][id]["T_POSY"] \
931 and x == world_db["Things"][id]["T_POSX"] \
932 and not world_db["Things"][id]["carried"]:
933 type = world_db["Things"][id]["T_TYPE"]
934 name = world_db["ThingTypes"][type]["TT_NAME"]
935 strong_write(io_db["file_out"], name + "\n")
937 for mt in world_db["Things"][0]["T_MEMTHING"]:
938 if y == mt[1] and x == mt[2]:
939 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
940 strong_write(io_db["file_out"], name + "\n")
941 strong_write(io_db["file_out"], "THINGS_HERE END\n")
943 print("Ignoring: Invalid map coordinates.")
945 print("Ignoring: Command only works on existing worlds.")
948 def play_commander(action, args=False):
949 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
951 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
955 id = [x for x in world_db["ThingActions"]
956 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
957 world_db["Things"][0]["T_COMMAND"] = id
960 def set_command_and_argument_int(str_arg):
961 val = integer_test(str_arg, 0, 255)
963 world_db["Things"][0]["T_ARGUMENT"] = val
966 def set_command_and_argument_movestring(str_arg):
967 if str_arg in directions_db:
968 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
971 print("Ignoring: Argument must be valid direction string.")
974 return set_command_and_argument_movestring
976 return set_command_and_argument_int
981 def command_seedrandomness(seed_string):
982 """Set rand seed to int(seed_string)."""
983 val = integer_test(seed_string, 0, 4294967295)
988 def command_seedmap(seed_string):
989 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
990 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
994 def command_makeworld(seed_string):
995 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
997 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
998 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
999 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1000 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1001 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1002 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1003 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1009 err = "Space to put thing on too hard to find. Map too small?"
1011 y = rand.next() % world_db["MAP_LENGTH"]
1012 x = rand.next() % world_db["MAP_LENGTH"]
1013 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1017 raise SystemExit(err)
1018 # Replica of C code, wrongly ignores animatedness of new Thing.
1019 pos_clear = (0 == len([id for id in world_db["Things"]
1020 if world_db["Things"][id]["T_LIFEPOINTS"]
1021 if world_db["Things"][id]["T_POSY"] == y
1022 if world_db["Things"][id]["T_POSX"] == x]))
1027 val = integer_test(seed_string, 0, 4294967295)
1031 world_db["SEED_MAP"] = val
1032 player_will_be_generated = False
1033 playertype = world_db["PLAYER_TYPE"]
1034 for ThingType in world_db["ThingTypes"]:
1035 if playertype == ThingType:
1036 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1037 player_will_be_generated = True
1039 if not player_will_be_generated:
1040 print("Ignoring beyond SEED_MAP: " +
1041 "No player type with start number >0 defined.")
1044 for ThingAction in world_db["ThingActions"]:
1045 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1048 print("Ignoring beyond SEED_MAP: " +
1049 "No thing action with name 'wait' defined.")
1051 world_db["Things"] = {}
1053 world_db["WORLD_ACTIVE"] = 1
1054 world_db["TURN"] = 1
1055 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1056 id = id_setter(-1, "Things")
1057 world_db["Things"][id] = new_Thing(playertype, free_pos())
1058 update_map_memory(world_db["Things"][0])
1059 for type in world_db["ThingTypes"]:
1060 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1061 if type != playertype:
1062 id = id_setter(-1, "Things")
1063 world_db["Things"][id] = new_Thing(type, free_pos())
1064 strong_write(io_db["file_out"], "NEW_WORLD\n")
1067 def command_maplength(maplength_string):
1068 """Redefine map length. Invalidate map, therefore lose all things on it."""
1069 val = integer_test(maplength_string, 1, 256)
1071 world_db["MAP_LENGTH"] = val
1072 set_world_inactive()
1073 world_db["Things"] = {}
1074 libpr.set_maplength(val)
1077 def command_worldactive(worldactive_string):
1078 """Toggle world_db["WORLD_ACTIVE"] if possible.
1080 An active world can always be set inactive. An inactive world can only be
1081 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1082 activation, rebuild all Things' FOVs, and the player's map memory.
1084 # In original version, map existence was also tested (unnecessarily?).
1085 val = integer_test(worldactive_string, 0, 1)
1087 if 0 != world_db["WORLD_ACTIVE"]:
1089 set_world_inactive()
1091 print("World already active.")
1092 elif 0 == world_db["WORLD_ACTIVE"]:
1094 for ThingAction in world_db["ThingActions"]:
1095 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1098 player_exists = False
1099 for Thing in world_db["Things"]:
1101 player_exists = True
1103 if wait_exists and player_exists:
1104 for id in world_db["Things"]:
1105 if world_db["Things"][id]["T_LIFEPOINTS"]:
1106 build_fov_map(world_db["Things"][id])
1108 update_map_memory(world_db["Things"][id])
1109 world_db["WORLD_ACTIVE"] = 1
1112 def test_for_id_maker(object, category):
1113 """Return decorator testing for object having "id" attribute."""
1116 if hasattr(object, "id"):
1119 print("Ignoring: No " + category +
1120 " defined to manipulate yet.")
1125 def command_tid(id_string):
1126 """Set ID of Thing to manipulate. ID unused? Create new one.
1128 Default new Thing's type to the first available ThingType, others: zero.
1130 id = id_setter(id_string, "Things", command_tid)
1132 if world_db["ThingTypes"] == {}:
1133 print("Ignoring: No ThingType to settle new Thing in.")
1135 type = list(world_db["ThingTypes"].keys())[0]
1136 world_db["Things"][id] = new_Thing(type)
1139 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1143 def command_tcommand(str_int):
1144 """Set T_COMMAND of selected Thing."""
1145 val = integer_test(str_int, 0, 255)
1147 if 0 == val or val in world_db["ThingActions"]:
1148 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1150 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1154 def command_ttype(str_int):
1155 """Set T_TYPE of selected Thing."""
1156 val = integer_test(str_int, 0, 255)
1158 if val in world_db["ThingTypes"]:
1159 world_db["Things"][command_tid.id]["T_TYPE"] = val
1161 print("Ignoring: ThingType ID belongs to no known ThingType.")
1165 def command_tcarries(str_int):
1166 """Append int(str_int) to T_CARRIES of selected Thing.
1168 The ID int(str_int) must not be of the selected Thing, and must belong to a
1169 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1171 val = integer_test(str_int, 0, 255)
1173 if val == command_tid.id:
1174 print("Ignoring: Thing cannot carry itself.")
1175 elif val in world_db["Things"] \
1176 and not world_db["Things"][val]["carried"]:
1177 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1178 world_db["Things"][val]["carried"] = True
1180 print("Ignoring: Thing not available for carrying.")
1181 # Note that the whole carrying structure is different from the C version:
1182 # Carried-ness is marked by a "carried" flag, not by Things containing
1183 # Things internally.
1187 def command_tmemthing(str_t, str_y, str_x):
1188 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1190 The type must fit to an existing ThingType, and the position into the map.
1192 type = integer_test(str_t, 0, 255)
1193 posy = integer_test(str_y, 0, 255)
1194 posx = integer_test(str_x, 0, 255)
1195 if None != type and None != posy and None != posx:
1196 if type not in world_db["ThingTypes"] \
1197 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1198 print("Ignoring: Illegal value for thing type or position.")
1200 memthing = (type, posy, posx)
1201 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1204 def setter_map(maptype):
1205 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1207 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1210 def helper(str_int, mapline):
1211 val = integer_test(str_int, 0, 255)
1213 if val >= world_db["MAP_LENGTH"]:
1214 print("Illegal value for map line number.")
1215 elif len(mapline) != world_db["MAP_LENGTH"]:
1216 print("Map line length is unequal map width.")
1218 length = world_db["MAP_LENGTH"]
1220 if not world_db["Things"][command_tid.id][maptype]:
1221 map = bytearray(b' ' * (length ** 2))
1223 map = world_db["Things"][command_tid.id][maptype]
1224 map[val * length:(val * length) + length] = mapline.encode()
1225 world_db["Things"][command_tid.id][maptype] = map
1229 def setter_tpos(axis):
1230 """Generate setter for T_POSX or T_POSY of selected Thing.
1232 If world is active, rebuilds animate things' fovmap, player's memory map.
1235 def helper(str_int):
1236 val = integer_test(str_int, 0, 255)
1238 if val < world_db["MAP_LENGTH"]:
1239 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1240 if world_db["WORLD_ACTIVE"] \
1241 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1242 build_fov_map(world_db["Things"][command_tid.id])
1243 if 0 == command_tid.id:
1244 update_map_memory(world_db["Things"][command_tid.id])
1246 print("Ignoring: Position is outside of map.")
1250 def command_ttid(id_string):
1251 """Set ID of ThingType to manipulate. ID unused? Create new one.
1253 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1255 id = id_setter(id_string, "ThingTypes", command_ttid)
1257 world_db["ThingTypes"][id] = {
1258 "TT_NAME": "(none)",
1261 "TT_PROLIFERATE": 0,
1262 "TT_START_NUMBER": 0,
1268 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1272 def command_ttname(name):
1273 """Set TT_NAME of selected ThingType."""
1274 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1278 def command_ttsymbol(char):
1279 """Set TT_SYMBOL of selected ThingType. """
1281 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1283 print("Ignoring: Argument must be single character.")
1287 def command_ttcorpseid(str_int):
1288 """Set TT_CORPSE_ID of selected ThingType."""
1289 val = integer_test(str_int, 0, 255)
1291 if val in world_db["ThingTypes"]:
1292 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1294 print("Ignoring: Corpse ID belongs to no known ThignType.")
1297 def command_taid(id_string):
1298 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1300 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1302 id = id_setter(id_string, "ThingActions", command_taid, True)
1304 world_db["ThingActions"][id] = {
1310 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1313 @test_ThingAction_id
1314 def command_taname(name):
1315 """Set TA_NAME of selected ThingAction.
1317 The name must match a valid thing action function. If after the name
1318 setting no ThingAction with name "wait" remains, call set_world_inactive().
1320 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1321 or name == "pick_up":
1322 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1323 if 1 == world_db["WORLD_ACTIVE"]:
1324 wait_defined = False
1325 for id in world_db["ThingActions"]:
1326 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1329 if not wait_defined:
1330 set_world_inactive()
1332 print("Ignoring: Invalid action name.")
1333 # In contrast to the original,naming won't map a function to a ThingAction.
1337 """Call ai() on player Thing, then turn_over()."""
1338 ai(world_db["Things"][0])
1342 """Commands database.
1344 Map command start tokens to ([0]) number of expected command arguments, ([1])
1345 the command's meta-ness (i.e. is it to be written to the record file, is it to
1346 be ignored in replay mode if read from server input file), and ([2]) a function
1350 "QUIT": (0, True, command_quit),
1351 "PING": (0, True, command_ping),
1352 "THINGS_HERE": (2, True, command_thingshere),
1353 "MAKE_WORLD": (1, False, command_makeworld),
1354 "SEED_MAP": (1, False, command_seedmap),
1355 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1356 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1357 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1358 "MAP_LENGTH": (1, False, command_maplength),
1359 "WORLD_ACTIVE": (1, False, command_worldactive),
1360 "TA_ID": (1, False, command_taid),
1361 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1362 "TA_NAME": (1, False, command_taname),
1363 "TT_ID": (1, False, command_ttid),
1364 "TT_NAME": (1, False, command_ttname),
1365 "TT_SYMBOL": (1, False, command_ttsymbol),
1366 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1367 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1369 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1371 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1373 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1374 "T_ID": (1, False, command_tid),
1375 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1376 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1377 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1378 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1379 "T_COMMAND": (1, False, command_tcommand),
1380 "T_TYPE": (1, False, command_ttype),
1381 "T_CARRIES": (1, False, command_tcarries),
1382 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1383 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1384 "T_MEMTHING": (3, False, command_tmemthing),
1385 "T_POSY": (1, False, setter_tpos("Y")),
1386 "T_POSX": (1, False, setter_tpos("X")),
1387 "wait": (0, False, play_commander("wait")),
1388 "move": (1, False, play_commander("move")),
1389 "pick_up": (0, False, play_commander("pick_up")),
1390 "drop": (1, False, play_commander("drop", True)),
1391 "use": (1, False, play_commander("use", True)),
1392 "ai": (0, False, command_ai)
1396 """World state database. With sane default values. (Randomness is in rand.)"""
1408 """Mapping of direction names to internal direction chars."""
1409 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1410 "west": "s", "north-west": "w", "north-east": "e"}
1412 """File IO database."""
1414 "path_save": "save",
1415 "path_record": "record",
1416 "path_worldconf": "confserver/world",
1417 "path_server": "server/",
1418 "path_in": "server/in",
1419 "path_out": "server/out",
1420 "path_worldstate": "server/worldstate",
1421 "tmp_suffix": "_tmp",
1422 "kicked_by_rival": False,
1423 "worldstate_updateable": False
1428 libpr = prep_library()
1429 rand = RandomnessIO()
1430 opts = parse_command_line_arguments()
1432 if None != opts.replay:
1436 except SystemExit as exit:
1437 print("ABORTING: " + exit.args[0])
1439 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")