3 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
4 # or any later version. For details on its copyright, license, and warranties,
5 # see the file NOTICE in the root directory of the PlomRogue source package.
18 """"Interface to libplomrogue's pseudo-randomness generator."""
20 def set_seed(self, seed):
21 libpr.seed_rrand(1, seed)
24 return libpr.seed_rrand(0, 0)
29 seed = property(get_seed, set_seed)
33 """Prepare ctypes library at ./libplomrogue.so"""
34 libpath = ("./libplomrogue.so")
35 if not os.access(libpath, os.F_OK):
36 raise SystemExit("No library " + libpath +
37 ", run ./compile-server.sh first?")
38 libpr = ctypes.cdll.LoadLibrary(libpath)
39 libpr.seed_rrand.argtypes = [ctypes.c_uint8, ctypes.c_uint32]
40 libpr.seed_rrand.restype = ctypes.c_uint32
41 libpr.rrand.argtypes = []
42 libpr.rrand.restype = ctypes.c_uint16
43 libpr.set_maplength.argtypes = [ctypes.c_uint16]
44 libpr.mv_yx_in_dir_legal_wrap.argtypes = [ctypes.c_char, ctypes.c_uint8,
46 libpr.mv_yx_in_dir_legal_wrap.restype = ctypes.c_uint8
47 libpr.result_y.restype = ctypes.c_uint8
48 libpr.result_x.restype = ctypes.c_uint8
49 libpr.set_maplength(world_db["MAP_LENGTH"])
50 libpr.build_fov_map.argtypes = [ctypes.c_uint8, ctypes.c_uint8,
51 ctypes.c_char_p, ctypes.c_char_p]
52 libpr.build_fov_map.restype = ctypes.c_uint8
53 libpr.init_score_map.restype = ctypes.c_uint8
54 libpr.set_map_score.argtypes = [ctypes.c_uint16, ctypes.c_uint16]
55 libpr.set_map_score.restype = ctypes.c_uint8
56 libpr.get_map_score.argtypes = [ctypes.c_uint16]
57 libpr.get_map_score.restype = ctypes.c_int32
58 libpr.get_neighbor_score.argtypes = [ctypes.c_uint8]
59 libpr.get_neighbor_score.restype = ctypes.c_uint16
60 libpr.ready_neighbor_scores.argtpes = [ctypes.c_uint16]
61 libpr.ready_neighbor_scores.restype = ctypes.c_uint8
62 libpr.dijkstra_map.restype = ctypes.c_uint8
66 def strong_write(file, string):
67 """Apply write(string), then flush()."""
72 def setup_server_io():
73 """Fill IO files DB with proper file( path)s. Write process IO test string.
75 Ensure IO files directory at server/. Remove any old input file if found.
76 Set up new input file for reading, and new output file for writing. Start
77 output file with process hash line of format PID + " " + floated UNIX time
78 (io_db["teststring"]). Raise SystemExit if file is found at path of either
79 record or save file plus io_db["tmp_suffix"].
81 def detect_atomic_leftover(path, tmp_suffix):
82 path_tmp = path + tmp_suffix
83 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
84 "aborted previous attempt to write '" + path + "'. Aborting " \
85 "until matter is resolved by removing it from its current path."
86 if os.access(path_tmp, os.F_OK):
88 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
89 io_db["save_wait"] = 0
90 io_db["verbose"] = False
91 io_db["record_chunk"] = ""
92 os.makedirs(io_db["path_server"], exist_ok=True)
93 io_db["file_out"] = open(io_db["path_out"], "w")
94 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
95 if os.access(io_db["path_in"], os.F_OK):
96 os.remove(io_db["path_in"])
97 io_db["file_in"] = open(io_db["path_in"], "w")
98 io_db["file_in"].close()
99 io_db["file_in"] = open(io_db["path_in"], "r")
100 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
101 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
104 def cleanup_server_io():
105 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
106 def helper(file_key, path_key):
107 if file_key in io_db:
108 io_db[file_key].close()
109 if not io_db["kicked_by_rival"] \
110 and os.access(io_db[path_key], os.F_OK):
111 os.remove(io_db[path_key])
112 helper("file_in", "path_in")
113 helper("file_out", "path_out")
114 helper("file_worldstate", "path_worldstate")
115 if "file_record" in io_db:
116 io_db["file_record"].close()
119 def obey(command, prefix, replay=False, do_record=False):
120 """Call function from commands_db mapped to command's first token.
122 Tokenize command string with shlex.split(comments=True). If replay is set,
123 a non-meta command from the commands_db merely triggers obey() on the next
124 command from the records file. If not, non-meta commands set
125 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
126 do_record is set, are recorded to io_db["record_chunk"], and save_world()
127 is called (and io_db["record_chunk"] written) if 15 seconds have passed
128 since the last time it was called. The prefix string is inserted into the
129 server's input message between its beginning 'input ' and ':'. All activity
130 is preceded by a server_test() call.
134 print("input " + prefix + ": " + command)
136 tokens = shlex.split(command, comments=True)
137 except ValueError as err:
138 print("Can't tokenize command string: " + str(err) + ".")
140 if len(tokens) > 0 and tokens[0] in commands_db \
141 and len(tokens) == commands_db[tokens[0]][0] + 1:
142 if commands_db[tokens[0]][1]:
143 commands_db[tokens[0]][2](*tokens[1:])
145 print("Due to replay mode, reading command as 'go on in record'.")
146 line = io_db["file_record"].readline()
148 obey(line.rstrip(), io_db["file_record"].prefix
149 + str(io_db["file_record"].line_n))
150 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
152 print("Reached end of record file.")
154 commands_db[tokens[0]][2](*tokens[1:])
156 io_db["record_chunk"] += command + "\n"
157 if time.time() > io_db["save_wait"] + 15:
158 atomic_write(io_db["path_record"], io_db["record_chunk"],
161 io_db["record_chunk"] = ""
162 io_db["save_wait"] = time.time()
163 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
164 elif 0 != len(tokens):
165 print("Invalid command/argument, or bad number of tokens.")
168 def atomic_write(path, text, do_append=False):
169 """Atomic write of text to file at path, appended if do_append is set."""
170 path_tmp = path + io_db["tmp_suffix"]
174 if os.access(path, os.F_OK):
175 shutil.copyfile(path, path_tmp)
176 file = open(path_tmp, mode)
177 strong_write(file, text)
179 if os.access(path, os.F_OK):
181 os.rename(path_tmp, path)
185 """Save all commands needed to reconstruct current world state."""
188 string = string.replace("\u005C", '\u005C\u005C')
189 return '"' + string.replace('"', '\u005C"') + '"'
194 if world_db["Things"][id][key]:
195 map = world_db["Things"][id][key]
196 length = world_db["MAP_LENGTH"]
197 for i in range(length):
198 line = map[i * length:(i * length) + length].decode()
199 string = string + key + " " + str(i) + " " + quote(line) \
206 for memthing in world_db["Things"][id]["T_MEMTHING"]:
207 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
208 str(memthing[1]) + " " + str(memthing[2]) + "\n"
211 def helper(category, id_string, special_keys={}):
213 for id in world_db[category]:
214 string = string + id_string + " " + str(id) + "\n"
215 for key in world_db[category][id]:
216 if not key in special_keys:
217 x = world_db[category][id][key]
218 argument = quote(x) if str == type(x) else str(x)
219 string = string + key + " " + argument + "\n"
220 elif special_keys[key]:
221 string = string + special_keys[key](id)
226 if dict != type(world_db[key]) and key != "MAP" and \
227 key != "WORLD_ACTIVE" and key != "SEED_MAP":
228 string = string + key + " " + str(world_db[key]) + "\n"
229 string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
230 string = string + helper("ThingActions", "TA_ID")
231 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
232 for id in world_db["ThingTypes"]:
233 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
234 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
235 string = string + helper("Things", "T_ID",
236 {"T_CARRIES": False, "carried": False,
237 "T_MEMMAP": mapsetter("T_MEMMAP"),
238 "T_MEMTHING": memthing, "fovmap": False,
239 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
240 for id in world_db["Things"]:
241 if [] != world_db["Things"][id]["T_CARRIES"]:
242 string = string + "T_ID " + str(id) + "\n"
243 for carried_id in world_db["Things"][id]["T_CARRIES"]:
244 string = string + "T_CARRIES " + str(carried_id) + "\n"
245 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
246 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
247 atomic_write(io_db["path_save"], string)
250 def obey_lines_in_file(path, name, do_record=False):
251 """Call obey() on each line of path's file, use name in input prefix."""
252 file = open(path, "r")
254 for line in file.readlines():
255 obey(line.rstrip(), name + "file line " + str(line_n),
261 def parse_command_line_arguments():
262 """Return settings values read from command line arguments."""
263 parser = argparse.ArgumentParser()
264 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
266 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
268 parser.add_argument('-v', dest='verbose', action='store_true')
269 opts, unknown = parser.parse_known_args()
274 """Ensure valid server out file belonging to current process.
276 This is done by comparing io_db["teststring"] to what's found at the start
277 of the current file at io_db["path_out"]. On failure, set
278 io_db["kicked_by_rival"] and raise SystemExit.
280 if not os.access(io_db["path_out"], os.F_OK):
281 raise SystemExit("Server output file has disappeared.")
282 file = open(io_db["path_out"], "r")
283 test = file.readline().rstrip("\n")
285 if test != io_db["teststring"]:
286 io_db["kicked_by_rival"] = True
287 msg = "Server test string in server output file does not match. This" \
288 " indicates that the current server process has been " \
289 "superseded by another one."
290 raise SystemExit(msg)
294 """Return next newline-delimited command from server in file.
296 Keep building return string until a newline is encountered. Pause between
297 unsuccessful reads, and after too much waiting, run server_test().
299 wait_on_fail = 0.03333
304 add = io_db["file_in"].readline()
306 command = command + add
307 if len(command) > 0 and "\n" == command[-1]:
308 command = command[:-1]
311 time.sleep(wait_on_fail)
312 if now + max_wait < time.time():
318 def try_worldstate_update():
319 """Write worldstate file if io_db["worldstate_updateable"] is set."""
320 if io_db["worldstate_updateable"]:
322 def draw_visible_Things(map, run):
323 for id in world_db["Things"]:
324 type = world_db["Things"][id]["T_TYPE"]
325 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
326 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
327 if (0 == run and not consumable and not alive) \
328 or (1 == run and consumable and not alive) \
329 or (2 == run and alive):
330 y = world_db["Things"][id]["T_POSY"]
331 x = world_db["Things"][id]["T_POSX"]
332 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
333 if 'v' == chr(fovflag):
334 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
335 map[(y * length) + x] = ord(c)
337 def write_map(string, map):
338 for i in range(length):
339 line = map[i * length:(i * length) + length].decode()
340 string = string + line + "\n"
344 if [] == world_db["Things"][0]["T_CARRIES"]:
345 inventory = "(none)\n"
347 for id in world_db["Things"][0]["T_CARRIES"]:
348 type_id = world_db["Things"][id]["T_TYPE"]
349 name = world_db["ThingTypes"][type_id]["TT_NAME"]
350 inventory = inventory + name + "\n"
351 string = str(world_db["TURN"]) + "\n" + \
352 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
353 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
354 inventory + "%\n" + \
355 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
356 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
357 str(world_db["MAP_LENGTH"]) + "\n"
358 length = world_db["MAP_LENGTH"]
359 fov = bytearray(b' ' * (length ** 2))
360 for pos in range(length ** 2):
361 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
362 fov[pos] = world_db["MAP"][pos]
364 draw_visible_Things(fov, i)
365 string = write_map(string, fov)
366 mem = world_db["Things"][0]["T_MEMMAP"][:]
368 for mt in world_db["Things"][0]["T_MEMTHING"]:
369 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
370 if (i == 0 and not consumable) or (i == 1 and consumable):
371 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
372 mem[(mt[1] * length) + mt[2]] = ord(c)
373 string = write_map(string, mem)
374 atomic_write(io_db["path_worldstate"], string)
375 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
376 io_db["worldstate_updateable"] = False
380 """Replay game from record file.
382 Use opts.replay as breakpoint turn to which to replay automatically before
383 switching to manual input by non-meta commands in server input file
384 triggering further reads of record file. Ensure opts.replay is at least 1.
385 Run try_worldstate_update() before each interactive obey()/read_command().
389 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
390 " (if so late a turn is to be found).")
391 if not os.access(io_db["path_record"], os.F_OK):
392 raise SystemExit("No record file found to replay.")
393 io_db["file_record"] = open(io_db["path_record"], "r")
394 io_db["file_record"].prefix = "record file line "
395 io_db["file_record"].line_n = 1
396 while world_db["TURN"] < opts.replay:
397 line = io_db["file_record"].readline()
400 obey(line.rstrip(), io_db["file_record"].prefix
401 + str(io_db["file_record"].line_n))
402 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
404 try_worldstate_update()
405 obey(read_command(), "in file", replay=True)
409 """Play game by server input file commands. Before, load save file found.
411 If no save file is found, a new world is generated from the commands in the
412 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
413 command and all that follow via the server input file. Run
414 try_worldstate_update() before each interactive obey()/read_command().
416 if os.access(io_db["path_save"], os.F_OK):
417 obey_lines_in_file(io_db["path_save"], "save")
419 if not os.access(io_db["path_worldconf"], os.F_OK):
420 msg = "No world config file from which to start a new world."
421 raise SystemExit(msg)
422 obey_lines_in_file(io_db["path_worldconf"], "world config ",
424 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
426 try_worldstate_update()
427 obey(read_command(), "in file", do_record=True)
431 """(Re-)make island map.
433 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
434 start with one land cell in the middle, then go into cycle of repeatedly
435 selecting a random sea cell and transforming it into land if it is neighbor
436 to land. The cycle ends when a land cell is due to be created at the map's
437 border. Then put some trees on the map (TODO: more precise algorithm desc).
439 def is_neighbor(coordinates, type):
442 length = world_db["MAP_LENGTH"]
444 diag_west = x + (ind > 0)
445 diag_east = x + (ind < (length - 1))
446 pos = (y * length) + x
447 if (y > 0 and diag_east
448 and type == chr(world_db["MAP"][pos - length + ind])) \
450 and type == chr(world_db["MAP"][pos + 1])) \
451 or (y < (length - 1) and diag_east
452 and type == chr(world_db["MAP"][pos + length + ind])) \
453 or (y > 0 and diag_west
454 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
456 and type == chr(world_db["MAP"][pos - 1])) \
457 or (y < (length - 1) and diag_west
458 and type == chr(world_db["MAP"][pos + length - (not ind)])):
461 store_seed = rand.seed
462 rand.seed = world_db["SEED_MAP"]
463 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
464 length = world_db["MAP_LENGTH"]
465 add_half_width = (not (length % 2)) * int(length / 2)
466 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
468 y = rand.next() % length
469 x = rand.next() % length
470 pos = (y * length) + x
471 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
472 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
474 world_db["MAP"][pos] = ord(".")
475 n_trees = int((length ** 2) / 16)
477 while (i_trees <= n_trees):
478 single_allowed = rand.next() % 32
479 y = rand.next() % length
480 x = rand.next() % length
481 pos = (y * length) + x
482 if "." == chr(world_db["MAP"][pos]) \
483 and ((not single_allowed) or is_neighbor((y, x), "X")):
484 world_db["MAP"][pos] = ord("X")
486 rand.seed = store_seed
487 # This all-too-precise replica of the original C code misses iter_limit().
490 def update_map_memory(t, age_map=True):
491 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
492 if not t["T_MEMMAP"]:
493 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
494 if not t["T_MEMDEPTHMAP"]:
495 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
500 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
501 if ord_v == t["fovmap"][pos]]:
502 t["T_MEMDEPTHMAP"][pos] = ord_0
503 if ord_space == t["T_MEMMAP"][pos]:
504 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
506 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
507 if not ord_v == t["fovmap"][pos]
508 if ord_0 <= t["T_MEMDEPTHMAP"][pos]
509 if ord_9 > t["T_MEMDEPTHMAP"][pos]
510 if not rand.next() % (2 **
511 (t["T_MEMDEPTHMAP"][pos] - 48))]:
512 t["T_MEMDEPTHMAP"][pos] += 1
513 for mt in [mt for mt in t["T_MEMTHING"]
514 if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
516 t["T_MEMTHING"].remove(mt)
517 for id in [id for id in world_db["Things"]
518 if not world_db["Things"][id]["carried"]]:
519 type = world_db["Things"][id]["T_TYPE"]
520 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
521 y = world_db["Things"][id]["T_POSY"]
522 x = world_db["Things"][id]["T_POSX"]
523 if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
524 t["T_MEMTHING"].append((type, y, x))
527 def set_world_inactive():
528 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
530 if os.access(io_db["path_worldstate"], os.F_OK):
531 os.remove(io_db["path_worldstate"])
532 world_db["WORLD_ACTIVE"] = 0
535 def integer_test(val_string, min, max):
536 """Return val_string if possible integer >= min and <= max, else None."""
538 val = int(val_string)
539 if val < min or val > max:
543 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
548 def setter(category, key, min, max):
549 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
552 val = integer_test(val_string, min, max)
556 if category == "Thing":
557 id_store = command_tid
558 decorator = test_Thing_id
559 elif category == "ThingType":
560 id_store = command_ttid
561 decorator = test_ThingType_id
562 elif category == "ThingAction":
563 id_store = command_taid
564 decorator = test_ThingAction_id
568 val = integer_test(val_string, min, max)
570 world_db[category + "s"][id_store.id][key] = val
574 def build_fov_map(t):
575 """Build Thing's FOV map."""
576 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
577 maptype = ctypes.c_char * len(world_db["MAP"])
578 test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
579 maptype.from_buffer(t["fovmap"]),
580 maptype.from_buffer(world_db["MAP"]))
582 raise RuntimeError("Malloc error in build_fov_Map().")
585 def decrement_lifepoints(t):
586 """Decrement t's lifepoints by 1, and if to zero, corpse it.
588 If t is the player avatar, only blank its fovmap, so that the client may
589 still display memory data. On non-player things, erase fovmap and memory.
591 t["T_LIFEPOINTS"] -= 1
592 if 0 == t["T_LIFEPOINTS"]:
593 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
594 if world_db["Things"][0] == t:
595 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
596 strong_write(io_db["file_out"], "LOG You die.\n")
599 t["T_MEMMAP"] = False
600 t["T_MEMDEPTHMAP"] = False
602 strong_write(io_db["file_out"], "LOG It dies.\n")
605 def mv_yx_in_dir_legal(dir, y, x):
606 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
607 dir_c = dir.encode("ascii")[0]
608 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
610 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
611 return (test, libpr.result_y(), libpr.result_x())
615 """Make t do nothing (but loudly, if player avatar)."""
616 if t == world_db["Things"][0]:
617 strong_write(io_db["file_out"], "LOG You wait.\n")
621 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
623 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
624 t["T_POSY"], t["T_POSX"])
625 if 1 == move_result[0]:
626 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
627 passable = "." == chr(world_db["MAP"][pos])
628 hitted = [id for id in world_db["Things"]
629 if world_db["Things"][id] != t
630 if world_db["Things"][id]["T_LIFEPOINTS"]
631 if world_db["Things"][id]["T_POSY"] == move_result[1]
632 if world_db["Things"][id]["T_POSX"] == move_result[2]]
635 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
636 hitter = "You" if t == world_db["Things"][0] else hitter_name
637 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
638 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
639 hitted = "you" if hit_id == 0 else hitted_name
640 verb = " wound " if hitter == "You" else " wounds "
641 strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
643 decrement_lifepoints(world_db["Things"][hit_id])
645 dir = [dir for dir in directions_db
646 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
648 t["T_POSY"] = move_result[1]
649 t["T_POSX"] = move_result[2]
650 for id in t["T_CARRIES"]:
651 world_db["Things"][id]["T_POSY"] = move_result[1]
652 world_db["Things"][id]["T_POSX"] = move_result[2]
654 if t == world_db["Things"][0]:
655 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
656 elif t == world_db["Things"][0]:
657 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
660 def actor_pick_up(t):
661 """Make t pick up (topmost?) Thing from ground into inventory."""
662 # Topmostness is actually not defined so far. Picks Thing with highest ID.
663 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
664 if not world_db["Things"][id]["carried"]
665 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
666 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
672 world_db["Things"][highest_id]["carried"] = True
673 t["T_CARRIES"].append(highest_id)
674 if t == world_db["Things"][0]:
675 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
676 elif t == world_db["Things"][0]:
677 err = "You try to pick up an object, but there is none."
678 strong_write(io_db["file_out"], "LOG " + err + "\n")
682 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
683 # TODO: Handle case where T_ARGUMENT matches nothing.
684 if len(t["T_CARRIES"]):
685 id = t["T_CARRIES"][t["T_ARGUMENT"]]
686 t["T_CARRIES"].remove(id)
687 world_db["Things"][id]["carried"] = False
688 if t == world_db["Things"][0]:
689 strong_write(io_db["file_out"], "LOG You drop an object.\n")
690 elif t == world_db["Things"][0]:
691 err = "You try to drop an object, but you own none."
692 strong_write(io_db["file_out"], "LOG " + err + "\n")
696 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
697 # TODO: Handle case where T_ARGUMENT matches nothing.
698 if len(t["T_CARRIES"]):
699 id = t["T_CARRIES"][t["T_ARGUMENT"]]
700 type = world_db["Things"][id]["T_TYPE"]
701 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
702 t["T_CARRIES"].remove(id)
703 del world_db["Things"][id]
704 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
705 if t == world_db["Things"][0]:
706 strong_write(io_db["file_out"],
707 "LOG You consume this object.\n")
708 elif t == world_db["Things"][0]:
709 strong_write(io_db["file_out"],
710 "LOG You try to use this object, but fail.\n")
711 elif t == world_db["Things"][0]:
712 strong_write(io_db["file_out"],
713 "LOG You try to use an object, but you own none.\n")
716 def thingproliferation(t):
717 """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
719 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
720 passable and not be inhabited by a Thing of the same type, or, if Thing is
721 animate, any other animate Thing. If there are several map cell candidates,
722 one is selected randomly.
724 def test_cell(t, y, x):
725 if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
726 for id in [id for id in world_db["Things"]
727 if y == world_db["Things"][id]["T_POSY"]
728 if x == world_db["Things"][id]["T_POSX"]
729 if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
730 or (t["T_LIFEPOINTS"] and
731 world_db["Things"][id]["T_LIFEPOINTS"])]:
735 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
736 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
738 for dir in [directions_db[key] for key in directions_db]:
739 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
740 if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
741 candidates.append((mv_result[1], mv_result[2]))
743 i = rand.next() % len(candidates)
744 id = id_setter(-1, "Things")
745 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
746 world_db["Things"][id] = newT
750 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
752 On success, decrease satiation score by 32.
754 if t["T_SATIATION"] > 0 \
755 and t["T_LIFEPOINTS"] < \
756 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
757 and 0 == (rand.next() % 31) \
758 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
759 if world_db["ThingActions"][id]["TA_NAME"] ==
761 t["T_LIFEPOINTS"] += 1
762 t["T_SATIATION"] -= 32
763 if t == world_db["Things"][0]:
764 strong_write(io_db["file_out"], "LOG You heal.\n")
766 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
767 strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
771 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
772 if t["T_SATIATION"] > -32768:
773 t["T_SATIATION"] -= 1
774 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
775 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
776 raise RuntimeError("A thing that should not hunger is hungering.")
777 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
778 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
779 if t == world_db["Things"][0]:
780 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
782 name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
783 strong_write(io_db["file_out"], "LOG " + name +
784 " suffers from hunger.\n")
785 decrement_lifepoints(t)
788 def get_dir_to_target(t, filter):
789 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
791 The path-wise nearest target is chosen, via the shortest available path.
792 Target must not be t. On succcess, return positive value, else False.
794 "a": Thing in FOV is below a certain distance, animate, but of ThingType
795 that is not t's, and starts out weaker than t is; build path as
796 avoiding things of t's ThingType
797 "f": neighbor cell (not inhabited by any animate Thing) further away from
798 animate Thing not further than x steps away and in FOV and of a
799 ThingType that is not t's, and starts out stronger or as strong as t
800 is currently; or (cornered), if no such flight cell, but Thing of
801 above criteria is too near,1 a cell closer to it, or, if less near,
803 "c": Thing in memorized map is consumable
804 "s": memory map cell with greatest-reachable degree of unexploredness
807 def set_map_score(pos, score):
808 test = libpr.set_map_score(pos, score)
810 raise RuntimeError("No score map allocated for set_map_score().")
812 def get_map_score(pos):
813 result = libpr.get_map_score(pos)
815 raise RuntimeError("No score map allocated for get_map_score().")
819 if t["fovmap"] and ("a" == filter or "f" == filter):
820 for id in world_db["Things"]:
821 Thing = world_db["Things"][id]
822 if Thing != t and Thing["T_LIFEPOINTS"] and \
823 t["T_TYPE"] != Thing["T_TYPE"] and \
824 'v' == chr(t["fovmap"][(Thing["T_POSY"]
825 * world_db["MAP_LENGTH"])
827 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
828 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
830 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
833 elif t["T_MEMMAP"] and "c" == filter:
834 for mt in t["T_MEMTHING"]:
835 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
837 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
841 def init_score_map():
842 test = libpr.init_score_map()
844 raise RuntimeError("Malloc error in init_score_map().")
848 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
849 if ord_dot == t["T_MEMMAP"][i]]:
850 set_map_score(i, 65535 - 1)
852 for id in world_db["Things"]:
853 Thing = world_db["Things"][id]
854 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
856 if t != Thing and Thing["T_LIFEPOINTS"] and \
857 t["T_TYPE"] != Thing["T_TYPE"] and \
858 ord_v == t["fovmap"][pos] and \
859 t["T_LIFEPOINTS"] > \
860 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
861 set_map_score(pos, 0)
862 elif t["T_TYPE"] == Thing["T_TYPE"]:
863 set_map_score(pos, 65535)
865 for id in [id for id in world_db["Things"]
866 if world_db["Things"][id]["T_LIFEPOINTS"]]:
867 Thing = world_db["Things"][id]
868 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
870 if t["T_TYPE"] != Thing["T_TYPE"] and \
871 ord_v == t["fovmap"][pos] and \
872 t["T_LIFEPOINTS"] <= \
873 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
874 set_map_score(pos, 0)
876 for mt in [mt for mt in t["T_MEMTHING"]
877 if ord_blank != t["T_MEMMAP"][mt[1]
878 * world_db["MAP_LENGTH"]
880 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
881 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
883 for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
884 if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
887 def rand_target_dir(neighbors, cmp, dirs):
890 for i in range(len(dirs)):
891 if cmp == neighbors[i]:
892 candidates.append(dirs[i])
894 return candidates[rand.next() % n_candidates] if n_candidates else 0
896 def get_neighbor_scores(dirs, eye_pos):
898 if libpr.ready_neighbor_scores(eye_pos):
899 raise RuntimeError("No score map allocated for " +
900 "ready_neighbor_scores.()")
901 for i in range(len(dirs)):
902 scores.append(libpr.get_neighbor_score(i))
905 def get_dir_from_neighbors():
906 dir_to_target = False
908 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
909 neighbors = get_neighbor_scores(dirs, eye_pos)
911 inhabited = [world_db["Things"][id]["T_POSY"]
912 * world_db["MAP_LENGTH"]
913 + world_db["Things"][id]["T_POSX"]
914 for id in world_db["Things"]
915 if world_db["Things"][id]["T_LIFEPOINTS"]]
916 for i in range(len(dirs)):
917 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
918 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
920 for pos in [pos for pos in inhabited if pos == pos_cmp]:
923 minmax_start = 0 if "f" == filter else 65535 - 1
924 minmax_neighbor = minmax_start
925 for i in range(len(dirs)):
926 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
927 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
928 or ("f" != filter and minmax_neighbor > neighbors[i]):
929 minmax_neighbor = neighbors[i]
930 if minmax_neighbor != minmax_start:
931 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
933 if not dir_to_target:
934 if 1 == get_map_score(eye_pos):
935 dir_to_target = rand_target_dir(neighbors, 0, dirs)
936 elif 3 >= get_map_score(eye_pos):
937 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
939 world_db["ThingActions"][id]["TA_NAME"]
942 elif dir_to_target and 3 < get_map_score(eye_pos):
944 elif "a" == filter and 10 <= get_map_score(eye_pos):
948 dir_to_target = False
950 run_i = 9 + 1 if "s" == filter else 1
951 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
954 mem_depth_c = b'9' if b' ' == mem_depth_c \
955 else bytes([mem_depth_c[0] - 1])
956 if libpr.dijkstra_map():
957 raise RuntimeError("No score map allocated for dijkstra_map().")
958 dir_to_target = get_dir_from_neighbors()
959 libpr.free_score_map()
960 if dir_to_target and str == type(dir_to_target):
961 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
962 if world_db["ThingActions"][id]["TA_NAME"]
964 t["T_ARGUMENT"] = ord(dir_to_target)
968 def standing_on_consumable(t):
969 """Return True/False whether t is standing on a consumable."""
970 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
971 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
972 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
973 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
979 def get_inventory_slot_to_consume(t):
980 """Return slot Id of strongest consumable in t's inventory, else -1."""
981 cmp_consumability = 0
984 for id in t["T_CARRIES"]:
985 type = world_db["Things"][id]["T_TYPE"]
986 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
987 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
994 """Determine next command/argment for actor t via AI algorithms.
996 AI will look for, and move towards, enemies (animate Things not of their
997 own ThingType); if they see none, they will consume consumables in their
998 inventory; if there are none, they will pick up what they stand on if they
999 stand on consumables; if they stand on none, they will move towards the
1000 next consumable they see or remember on the map; if they see or remember
1001 none, they will explore parts of the map unseen since ever or for at least
1002 one turn; if there is nothing to explore, they will simply wait.
1004 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1005 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1006 if not get_dir_to_target(t, "f"):
1007 sel = get_inventory_slot_to_consume(t)
1009 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1010 if world_db["ThingActions"][id]["TA_NAME"]
1012 t["T_ARGUMENT"] = sel
1013 elif standing_on_consumable(t):
1014 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1015 if world_db["ThingActions"][id]["TA_NAME"]
1017 elif (not get_dir_to_target(t, "c")) and \
1018 (not get_dir_to_target(t, "a")):
1019 get_dir_to_target(t, "s")
1023 """Run game world and its inhabitants until new player input expected."""
1025 whilebreaker = False
1026 while world_db["Things"][0]["T_LIFEPOINTS"]:
1027 for id in [id for id in world_db["Things"]]: # Only what's from start!
1028 if not id in world_db["Things"] or \
1029 world_db["Things"][id]["carried"]: # May have been consumed or
1030 continue # picked up during turn …
1031 Thing = world_db["Things"][id]
1032 if Thing["T_LIFEPOINTS"]:
1033 if not Thing["T_COMMAND"]:
1034 update_map_memory(Thing)
1040 Thing["T_PROGRESS"] += 1
1041 taid = [a for a in world_db["ThingActions"]
1042 if a == Thing["T_COMMAND"]][0]
1043 ThingAction = world_db["ThingActions"][taid]
1044 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1045 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1046 Thing["T_COMMAND"] = 0
1047 Thing["T_PROGRESS"] = 0
1049 thingproliferation(Thing)
1052 world_db["TURN"] += 1
1055 def new_Thing(type, pos=(0, 0)):
1056 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1058 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1070 "T_MEMDEPTHMAP": False,
1073 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1074 build_fov_map(thing)
1078 def id_setter(id, category, id_store=False, start_at_1=False):
1079 """Set ID of object of category to manipulate ID unused? Create new one.
1081 The ID is stored as id_store.id (if id_store is set). If the integer of the
1082 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
1083 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
1084 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
1085 new object is created, otherwise the new object's ID.
1087 min = 0 if start_at_1 else -32768
1088 max = 255 if start_at_1 else 32767
1090 id = integer_test(id, min, max)
1092 if id in world_db[category]:
1097 if (start_at_1 and 0 == id) \
1098 or ((not start_at_1) and (id < 0 or id > 255)):
1102 if id not in world_db[category]:
1106 "No unused ID available to add to ID list.")
1114 """Send PONG line to server output file."""
1115 strong_write(io_db["file_out"], "PONG\n")
1119 """Abort server process."""
1121 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1122 raise SystemExit("received QUIT command")
1125 def command_thingshere(str_y, str_x):
1126 """Write to out file list of Things known to player at coordinate y, x."""
1127 if world_db["WORLD_ACTIVE"]:
1128 y = integer_test(str_y, 0, 255)
1129 x = integer_test(str_x, 0, 255)
1130 length = world_db["MAP_LENGTH"]
1131 if None != y and None != x and y < length and x < length:
1132 pos = (y * world_db["MAP_LENGTH"]) + x
1133 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1134 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1135 for id in world_db["Things"]:
1136 if y == world_db["Things"][id]["T_POSY"] \
1137 and x == world_db["Things"][id]["T_POSX"] \
1138 and not world_db["Things"][id]["carried"]:
1139 type = world_db["Things"][id]["T_TYPE"]
1140 name = world_db["ThingTypes"][type]["TT_NAME"]
1141 strong_write(io_db["file_out"], name + "\n")
1143 for mt in world_db["Things"][0]["T_MEMTHING"]:
1144 if y == mt[1] and x == mt[2]:
1145 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1146 strong_write(io_db["file_out"], name + "\n")
1147 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1149 print("Ignoring: Invalid map coordinates.")
1151 print("Ignoring: Command only works on existing worlds.")
1154 def play_commander(action, args=False):
1155 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1157 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1161 id = [x for x in world_db["ThingActions"]
1162 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1163 world_db["Things"][0]["T_COMMAND"] = id
1166 def set_command_and_argument_int(str_arg):
1167 val = integer_test(str_arg, 0, 255)
1169 world_db["Things"][0]["T_ARGUMENT"] = val
1172 def set_command_and_argument_movestring(str_arg):
1173 if str_arg in directions_db:
1174 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1177 print("Ignoring: Argument must be valid direction string.")
1179 if action == "move":
1180 return set_command_and_argument_movestring
1182 return set_command_and_argument_int
1187 def command_seedrandomness(seed_string):
1188 """Set rand seed to int(seed_string)."""
1189 val = integer_test(seed_string, 0, 4294967295)
1194 def command_seedmap(seed_string):
1195 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
1196 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
1200 def command_makeworld(seed_string):
1201 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1203 Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
1204 "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
1205 TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
1206 and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1207 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1208 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1209 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1215 err = "Space to put thing on too hard to find. Map too small?"
1217 y = rand.next() % world_db["MAP_LENGTH"]
1218 x = rand.next() % world_db["MAP_LENGTH"]
1219 if "." == chr(world_db["MAP"][y * world_db["MAP_LENGTH"] + x]):
1223 raise SystemExit(err)
1224 # Replica of C code, wrongly ignores animatedness of new Thing.
1225 pos_clear = (0 == len([id for id in world_db["Things"]
1226 if world_db["Things"][id]["T_LIFEPOINTS"]
1227 if world_db["Things"][id]["T_POSY"] == y
1228 if world_db["Things"][id]["T_POSX"] == x]))
1233 val = integer_test(seed_string, 0, 4294967295)
1237 world_db["SEED_MAP"] = val
1238 player_will_be_generated = False
1239 playertype = world_db["PLAYER_TYPE"]
1240 for ThingType in world_db["ThingTypes"]:
1241 if playertype == ThingType:
1242 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1243 player_will_be_generated = True
1245 if not player_will_be_generated:
1246 print("Ignoring beyond SEED_MAP: " +
1247 "No player type with start number >0 defined.")
1250 for ThingAction in world_db["ThingActions"]:
1251 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1254 print("Ignoring beyond SEED_MAP: " +
1255 "No thing action with name 'wait' defined.")
1257 world_db["Things"] = {}
1259 world_db["WORLD_ACTIVE"] = 1
1260 world_db["TURN"] = 1
1261 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1262 id = id_setter(-1, "Things")
1263 world_db["Things"][id] = new_Thing(playertype, free_pos())
1264 update_map_memory(world_db["Things"][0])
1265 for type in world_db["ThingTypes"]:
1266 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1267 if type != playertype:
1268 id = id_setter(-1, "Things")
1269 world_db["Things"][id] = new_Thing(type, free_pos())
1270 strong_write(io_db["file_out"], "NEW_WORLD\n")
1273 def command_maplength(maplength_string):
1274 """Redefine map length. Invalidate map, therefore lose all things on it."""
1275 val = integer_test(maplength_string, 1, 256)
1277 world_db["MAP_LENGTH"] = val
1278 set_world_inactive()
1279 world_db["Things"] = {}
1280 libpr.set_maplength(val)
1283 def command_worldactive(worldactive_string):
1284 """Toggle world_db["WORLD_ACTIVE"] if possible.
1286 An active world can always be set inactive. An inactive world can only be
1287 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
1288 activation, rebuild all Things' FOVs, and the player's map memory.
1290 # In original version, map existence was also tested (unnecessarily?).
1291 val = integer_test(worldactive_string, 0, 1)
1293 if 0 != world_db["WORLD_ACTIVE"]:
1295 set_world_inactive()
1297 print("World already active.")
1298 elif 0 == world_db["WORLD_ACTIVE"]:
1300 for ThingAction in world_db["ThingActions"]:
1301 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1304 player_exists = False
1305 for Thing in world_db["Things"]:
1307 player_exists = True
1309 if wait_exists and player_exists:
1310 for id in world_db["Things"]:
1311 if world_db["Things"][id]["T_LIFEPOINTS"]:
1312 build_fov_map(world_db["Things"][id])
1314 update_map_memory(world_db["Things"][id], False)
1315 world_db["WORLD_ACTIVE"] = 1
1318 def test_for_id_maker(object, category):
1319 """Return decorator testing for object having "id" attribute."""
1322 if hasattr(object, "id"):
1325 print("Ignoring: No " + category +
1326 " defined to manipulate yet.")
1331 def command_tid(id_string):
1332 """Set ID of Thing to manipulate. ID unused? Create new one.
1334 Default new Thing's type to the first available ThingType, others: zero.
1336 id = id_setter(id_string, "Things", command_tid)
1338 if world_db["ThingTypes"] == {}:
1339 print("Ignoring: No ThingType to settle new Thing in.")
1341 type = list(world_db["ThingTypes"].keys())[0]
1342 world_db["Things"][id] = new_Thing(type)
1345 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1349 def command_tcommand(str_int):
1350 """Set T_COMMAND of selected Thing."""
1351 val = integer_test(str_int, 0, 255)
1353 if 0 == val or val in world_db["ThingActions"]:
1354 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1356 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1360 def command_ttype(str_int):
1361 """Set T_TYPE of selected Thing."""
1362 val = integer_test(str_int, 0, 255)
1364 if val in world_db["ThingTypes"]:
1365 world_db["Things"][command_tid.id]["T_TYPE"] = val
1367 print("Ignoring: ThingType ID belongs to no known ThingType.")
1371 def command_tcarries(str_int):
1372 """Append int(str_int) to T_CARRIES of selected Thing.
1374 The ID int(str_int) must not be of the selected Thing, and must belong to a
1375 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1377 val = integer_test(str_int, 0, 255)
1379 if val == command_tid.id:
1380 print("Ignoring: Thing cannot carry itself.")
1381 elif val in world_db["Things"] \
1382 and not world_db["Things"][val]["carried"]:
1383 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1384 world_db["Things"][val]["carried"] = True
1386 print("Ignoring: Thing not available for carrying.")
1387 # Note that the whole carrying structure is different from the C version:
1388 # Carried-ness is marked by a "carried" flag, not by Things containing
1389 # Things internally.
1393 def command_tmemthing(str_t, str_y, str_x):
1394 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1396 The type must fit to an existing ThingType, and the position into the map.
1398 type = integer_test(str_t, 0, 255)
1399 posy = integer_test(str_y, 0, 255)
1400 posx = integer_test(str_x, 0, 255)
1401 if None != type and None != posy and None != posx:
1402 if type not in world_db["ThingTypes"] \
1403 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1404 print("Ignoring: Illegal value for thing type or position.")
1406 memthing = (type, posy, posx)
1407 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1410 def setter_map(maptype):
1411 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
1413 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
1416 def helper(str_int, mapline):
1417 val = integer_test(str_int, 0, 255)
1419 if val >= world_db["MAP_LENGTH"]:
1420 print("Illegal value for map line number.")
1421 elif len(mapline) != world_db["MAP_LENGTH"]:
1422 print("Map line length is unequal map width.")
1424 length = world_db["MAP_LENGTH"]
1426 if not world_db["Things"][command_tid.id][maptype]:
1427 map = bytearray(b' ' * (length ** 2))
1429 map = world_db["Things"][command_tid.id][maptype]
1430 map[val * length:(val * length) + length] = mapline.encode()
1431 world_db["Things"][command_tid.id][maptype] = map
1435 def setter_tpos(axis):
1436 """Generate setter for T_POSX or T_POSY of selected Thing.
1438 If world is active, rebuilds animate things' fovmap, player's memory map.
1441 def helper(str_int):
1442 val = integer_test(str_int, 0, 255)
1444 if val < world_db["MAP_LENGTH"]:
1445 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1446 if world_db["WORLD_ACTIVE"] \
1447 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1448 build_fov_map(world_db["Things"][command_tid.id])
1449 if 0 == command_tid.id:
1450 update_map_memory(world_db["Things"][command_tid.id])
1452 print("Ignoring: Position is outside of map.")
1456 def command_ttid(id_string):
1457 """Set ID of ThingType to manipulate. ID unused? Create new one.
1459 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1461 id = id_setter(id_string, "ThingTypes", command_ttid)
1463 world_db["ThingTypes"][id] = {
1464 "TT_NAME": "(none)",
1467 "TT_PROLIFERATE": 0,
1468 "TT_START_NUMBER": 0,
1474 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1478 def command_ttname(name):
1479 """Set TT_NAME of selected ThingType."""
1480 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1484 def command_ttsymbol(char):
1485 """Set TT_SYMBOL of selected ThingType. """
1487 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1489 print("Ignoring: Argument must be single character.")
1493 def command_ttcorpseid(str_int):
1494 """Set TT_CORPSE_ID of selected ThingType."""
1495 val = integer_test(str_int, 0, 255)
1497 if val in world_db["ThingTypes"]:
1498 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1500 print("Ignoring: Corpse ID belongs to no known ThignType.")
1503 def command_taid(id_string):
1504 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1506 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1508 id = id_setter(id_string, "ThingActions", command_taid, True)
1510 world_db["ThingActions"][id] = {
1516 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1519 @test_ThingAction_id
1520 def command_taname(name):
1521 """Set TA_NAME of selected ThingAction.
1523 The name must match a valid thing action function. If after the name
1524 setting no ThingAction with name "wait" remains, call set_world_inactive().
1526 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1527 or name == "pick_up":
1528 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1529 if 1 == world_db["WORLD_ACTIVE"]:
1530 wait_defined = False
1531 for id in world_db["ThingActions"]:
1532 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1535 if not wait_defined:
1536 set_world_inactive()
1538 print("Ignoring: Invalid action name.")
1539 # In contrast to the original,naming won't map a function to a ThingAction.
1543 """Call ai() on player Thing, then turn_over()."""
1544 ai(world_db["Things"][0])
1548 """Commands database.
1550 Map command start tokens to ([0]) number of expected command arguments, ([1])
1551 the command's meta-ness (i.e. is it to be written to the record file, is it to
1552 be ignored in replay mode if read from server input file), and ([2]) a function
1556 "QUIT": (0, True, command_quit),
1557 "PING": (0, True, command_ping),
1558 "THINGS_HERE": (2, True, command_thingshere),
1559 "MAKE_WORLD": (1, False, command_makeworld),
1560 "SEED_MAP": (1, False, command_seedmap),
1561 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1562 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1563 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
1564 "MAP_LENGTH": (1, False, command_maplength),
1565 "WORLD_ACTIVE": (1, False, command_worldactive),
1566 "TA_ID": (1, False, command_taid),
1567 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1568 "TA_NAME": (1, False, command_taname),
1569 "TT_ID": (1, False, command_ttid),
1570 "TT_NAME": (1, False, command_ttname),
1571 "TT_SYMBOL": (1, False, command_ttsymbol),
1572 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1573 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1575 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1577 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1579 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1580 "T_ID": (1, False, command_tid),
1581 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1582 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1583 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1584 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1585 "T_COMMAND": (1, False, command_tcommand),
1586 "T_TYPE": (1, False, command_ttype),
1587 "T_CARRIES": (1, False, command_tcarries),
1588 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1589 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1590 "T_MEMTHING": (3, False, command_tmemthing),
1591 "T_POSY": (1, False, setter_tpos("Y")),
1592 "T_POSX": (1, False, setter_tpos("X")),
1593 "wait": (0, False, play_commander("wait")),
1594 "move": (1, False, play_commander("move")),
1595 "pick_up": (0, False, play_commander("pick_up")),
1596 "drop": (1, False, play_commander("drop", True)),
1597 "use": (1, False, play_commander("use", True)),
1598 "ai": (0, False, command_ai)
1602 """World state database. With sane default values. (Randomness is in rand.)"""
1614 """Mapping of direction names to internal direction chars."""
1615 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1616 "west": "s", "north-west": "w", "north-east": "e"}
1618 """File IO database."""
1620 "path_save": "save",
1621 "path_record": "record_save",
1622 "path_worldconf": "confserver/world",
1623 "path_server": "server/",
1624 "path_in": "server/in",
1625 "path_out": "server/out",
1626 "path_worldstate": "server/worldstate",
1627 "tmp_suffix": "_tmp",
1628 "kicked_by_rival": False,
1629 "worldstate_updateable": False
1634 libpr = prep_library()
1635 rand = RandomnessIO()
1636 opts = parse_command_line_arguments()
1638 io_db["path_save"] = opts.savefile
1639 io_db["path_record"] = "record_" + opts.savefile
1642 io_db["verbose"] = True
1643 if None != opts.replay:
1647 except SystemExit as exit:
1648 print("ABORTING: " + exit.args[0])
1650 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")