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.
19 """"Interface to libplomrogue's pseudo-randomness generator."""
21 def set_seed(self, seed):
22 libpr.seed_rrand(1, seed)
25 return libpr.seed_rrand(0, 0)
30 seed = property(get_seed, set_seed)
34 """Prepare ctypes library at ./libplomrogue.so"""
35 libpath = ("./libplomrogue.so")
36 if not os.access(libpath, os.F_OK):
37 raise SystemExit("No library " + libpath + ", run ./redo first?")
38 libpr = ctypes.cdll.LoadLibrary(libpath)
39 libpr.seed_rrand.restype = ctypes.c_uint32
43 def c_pointer_to_bytearray(ba):
44 """Return C char * pointer to ba."""
45 type = ctypes.c_char * len(ba)
46 return type.from_buffer(ba)
49 def strong_write(file, string):
50 """Apply write(string), then flush()."""
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 io_db["save_wait"] = 0
73 io_db["verbose"] = False
74 io_db["record_chunk"] = ""
75 os.makedirs(io_db["path_server"], exist_ok=True)
76 io_db["file_out"] = open(io_db["path_out"], "w")
77 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
78 if os.access(io_db["path_in"], os.F_OK):
79 os.remove(io_db["path_in"])
80 io_db["file_in"] = open(io_db["path_in"], "w")
81 io_db["file_in"].close()
82 io_db["file_in"] = open(io_db["path_in"], "r")
83 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
84 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
87 def cleanup_server_io():
88 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
89 def helper(file_key, path_key):
91 io_db[file_key].close()
92 if not io_db["kicked_by_rival"] \
93 and os.access(io_db[path_key], os.F_OK):
94 os.remove(io_db[path_key])
95 helper("file_in", "path_in")
96 helper("file_out", "path_out")
97 helper("file_worldstate", "path_worldstate")
98 if "file_record" in io_db:
99 io_db["file_record"].close()
102 def obey(command, prefix, replay=False, do_record=False):
103 """Call function from commands_db mapped to command's first token.
105 Tokenize command string with shlex.split(comments=True). If replay is set,
106 a non-meta command from the commands_db merely triggers obey() on the next
107 command from the records file. If not, non-meta commands set
108 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
109 do_record is set, are recorded to io_db["record_chunk"], and save_world()
110 is called (and io_db["record_chunk"] written) if 15 seconds have passed
111 since the last time it was called. The prefix string is inserted into the
112 server's input message between its beginning 'input ' and ':'. All activity
113 is preceded by a server_test() call. Commands that start with a lowercase
114 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
118 print("input " + prefix + ": " + command)
120 tokens = shlex.split(command, comments=True)
121 except ValueError as err:
122 print("Can't tokenize command string: " + str(err) + ".")
124 if len(tokens) > 0 and tokens[0] in commands_db \
125 and len(tokens) == commands_db[tokens[0]][0] + 1:
126 if commands_db[tokens[0]][1]:
127 commands_db[tokens[0]][2](*tokens[1:])
128 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
129 print("Ignoring lowercase-starting commands when world inactive.")
131 print("Due to replay mode, reading command as 'go on in record'.")
132 line = io_db["file_record"].readline()
134 obey(line.rstrip(), io_db["file_record"].prefix
135 + str(io_db["file_record"].line_n))
136 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
138 print("Reached end of record file.")
140 commands_db[tokens[0]][2](*tokens[1:])
142 io_db["record_chunk"] += command + "\n"
143 if time.time() > io_db["save_wait"] + 15:
144 atomic_write(io_db["path_record"], io_db["record_chunk"],
146 if world_db["WORLD_ACTIVE"]:
148 io_db["record_chunk"] = ""
149 io_db["save_wait"] = time.time()
150 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
151 elif 0 != len(tokens):
152 print("Invalid command/argument, or bad number of tokens.")
155 def atomic_write(path, text, do_append=False, delete=True):
156 """Atomic write of text to file at path, appended if do_append is set."""
157 path_tmp = path + io_db["tmp_suffix"]
161 if os.access(path, os.F_OK):
162 shutil.copyfile(path, path_tmp)
163 file = open(path_tmp, mode)
164 strong_write(file, text)
166 if delete and os.access(path, os.F_OK):
168 os.rename(path_tmp, path)
172 """Save all commands needed to reconstruct current world state."""
175 string = string.replace("\u005C", '\u005C\u005C')
176 return '"' + string.replace('"', '\u005C"') + '"'
181 if key == "MAP" or world_db["Things"][id][key]:
182 map = world_db["MAP"] if key == "MAP" \
183 else world_db["Things"][id][key]
184 length = world_db["MAP_LENGTH"]
185 for i in range(length):
186 line = map[i * length:(i * length) + length].decode()
187 string = string + key + " " + str(i) + " " + quote(line) \
194 for memthing in world_db["Things"][id]["T_MEMTHING"]:
195 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
196 str(memthing[1]) + " " + str(memthing[2]) + "\n"
199 def helper(category, id_string, special_keys={}):
201 for id in world_db[category]:
202 string = string + id_string + " " + str(id) + "\n"
203 for key in world_db[category][id]:
204 if not key in special_keys:
205 x = world_db[category][id][key]
206 argument = quote(x) if str == type(x) else str(x)
207 string = string + key + " " + argument + "\n"
208 elif special_keys[key]:
209 string = string + special_keys[key](id)
214 if (dict != type(world_db[key])
215 and key != "altar" # #
216 and key != "MAP" and key != "WORLD_ACTIVE"):
217 string = string + key + " " + str(world_db[key]) + "\n"
218 string = string + mapsetter("MAP")()
219 string = string + helper("ThingActions", "TA_ID")
220 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
221 for id in world_db["ThingTypes"]:
222 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
223 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
224 string = string + helper("Things", "T_ID",
225 {"T_CARRIES": False, "carried": False,
226 "T_MEMMAP": mapsetter("T_MEMMAP"),
227 "T_MEMTHING": memthing, "fovmap": False,
228 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
229 for id in world_db["Things"]:
230 if [] != world_db["Things"][id]["T_CARRIES"]:
231 string = string + "T_ID " + str(id) + "\n"
232 for carried_id in world_db["Things"][id]["T_CARRIES"]:
233 string = string + "T_CARRIES " + str(carried_id) + "\n"
234 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
235 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
236 atomic_write(io_db["path_save"], string)
239 def obey_lines_in_file(path, name, do_record=False):
240 """Call obey() on each line of path's file, use name in input prefix."""
241 file = open(path, "r")
243 for line in file.readlines():
244 obey(line.rstrip(), name + "file line " + str(line_n),
250 def parse_command_line_arguments():
251 """Return settings values read from command line arguments."""
252 parser = argparse.ArgumentParser()
253 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
255 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
257 parser.add_argument('-v', dest='verbose', action='store_true')
258 opts, unknown = parser.parse_known_args()
263 """Ensure valid server out file belonging to current process.
265 This is done by comparing io_db["teststring"] to what's found at the start
266 of the current file at io_db["path_out"]. On failure, set
267 io_db["kicked_by_rival"] and raise SystemExit.
269 if not os.access(io_db["path_out"], os.F_OK):
270 raise SystemExit("Server output file has disappeared.")
271 file = open(io_db["path_out"], "r")
272 test = file.readline().rstrip("\n")
274 if test != io_db["teststring"]:
275 io_db["kicked_by_rival"] = True
276 msg = "Server test string in server output file does not match. This" \
277 " indicates that the current server process has been " \
278 "superseded by another one."
279 raise SystemExit(msg)
283 """Return next newline-delimited command from server in file.
285 Keep building return string until a newline is encountered. Pause between
286 unsuccessful reads, and after too much waiting, run server_test().
288 wait_on_fail = 0.03333
293 add = io_db["file_in"].readline()
295 command = command + add
296 if len(command) > 0 and "\n" == command[-1]:
297 command = command[:-1]
300 time.sleep(wait_on_fail)
301 if now + max_wait < time.time():
307 def try_worldstate_update():
308 """Write worldstate file if io_db["worldstate_updateable"] is set."""
309 if io_db["worldstate_updateable"]:
311 def write_map(string, map):
312 for i in range(length):
313 line = map[i * length:(i * length) + length].decode()
314 string = string + line + "\n"
318 if [] == world_db["Things"][0]["T_CARRIES"]:
319 inventory = "(none)\n"
321 for id in world_db["Things"][0]["T_CARRIES"]:
322 type_id = world_db["Things"][id]["T_TYPE"]
323 name = world_db["ThingTypes"][type_id]["TT_NAME"]
324 inventory = inventory + name + "\n"
325 # 7DRL additions: GOD_MOOD, GOD_FAVOR
326 string = str(world_db["TURN"]) + "\n" + \
327 str(world_db["GOD_MOOD"]) + "\n" + \
328 str(world_db["GOD_FAVOR"]) + "\n" + \
329 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
330 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
331 inventory + "%\n" + \
332 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
333 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
334 str(world_db["MAP_LENGTH"]) + "\n"
335 length = world_db["MAP_LENGTH"]
337 fov = bytearray(b' ' * (length ** 2))
339 for pos in [pos for pos in range(length ** 2)
340 if ord_v == world_db["Things"][0]["fovmap"][pos]]:
341 fov[pos] = world_db["MAP"][pos]
342 for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
343 for id in world_db["Things"]
344 if not world_db["Things"][id]["carried"]
345 if world_db["Things"][id]["T_TYPE"] == tid
346 if world_db["Things"][0]["fovmap"][
347 world_db["Things"][id]["T_POSY"] * length
348 + world_db["Things"][id]["T_POSX"]] == ord_v]:
349 type = world_db["Things"][id]["T_TYPE"]
350 c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
351 fov[world_db["Things"][id]["T_POSY"] * length
352 + world_db["Things"][id]["T_POSX"]] = c
353 string = write_map(string, fov)
355 mem = world_db["Things"][0]["T_MEMMAP"][:]
356 for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
357 for mt in world_db["Things"][0]["T_MEMTHING"]
359 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
360 mem[(mt[1] * length) + mt[2]] = ord(c)
361 string = write_map(string, mem)
363 stacksmap = bytearray(b'0' * (length ** 2)) # #
364 for id in [id for id in world_db["Things"] # #
365 if not world_db["Things"][id]["carried"] # #
366 if world_db["Things"][id]["T_LIFEPOINTS"]
367 if world_db["Things"][0]["fovmap"][ # #
368 world_db["Things"][id]["T_POSY"] * length # #
369 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
370 pos = (world_db["Things"][id]["T_POSY"] * length # #
371 + world_db["Things"][id]["T_POSX"]) # #
372 stacksmap[pos] = ord('X') # #
373 for id in [id for id in world_db["Things"] # #
374 if not world_db["Things"][id]["carried"] # #
375 if world_db["Things"][0]["fovmap"][ # #
376 world_db["Things"][id]["T_POSY"] * length # #
377 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
378 pos = (world_db["Things"][id]["T_POSY"] * length # #
379 + world_db["Things"][id]["T_POSX"]) # #
380 if stacksmap[pos] < ord('2'): # #
381 stacksmap[pos] += 1 # #
382 for mt in world_db["Things"][0]["T_MEMTHING"]: # #
383 pos = mt[1] * length + mt[2] # #
384 if stacksmap[pos] < ord('2'): # #
385 stacksmap[pos] += 1 # #
386 string = write_map(string, stacksmap) # #
388 atomic_write(io_db["path_worldstate"], string, delete=False)
389 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
390 io_db["worldstate_updateable"] = False
394 """Replay game from record file.
396 Use opts.replay as breakpoint turn to which to replay automatically before
397 switching to manual input by non-meta commands in server input file
398 triggering further reads of record file. Ensure opts.replay is at least 1.
399 Run try_worldstate_update() before each interactive obey()/read_command().
403 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
404 " (if so late a turn is to be found).")
405 if not os.access(io_db["path_record"], os.F_OK):
406 raise SystemExit("No record file found to replay.")
407 io_db["file_record"] = open(io_db["path_record"], "r")
408 io_db["file_record"].prefix = "record file line "
409 io_db["file_record"].line_n = 1
410 while world_db["TURN"] < opts.replay:
411 line = io_db["file_record"].readline()
414 obey(line.rstrip(), io_db["file_record"].prefix
415 + str(io_db["file_record"].line_n))
416 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
418 try_worldstate_update()
419 obey(read_command(), "in file", replay=True)
423 """Play game by server input file commands. Before, load save file found.
425 If no save file is found, a new world is generated from the commands in the
426 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
427 command and all that follow via the server input file. Run
428 try_worldstate_update() before each interactive obey()/read_command().
430 if os.access(io_db["path_save"], os.F_OK):
431 obey_lines_in_file(io_db["path_save"], "save")
433 if not os.access(io_db["path_worldconf"], os.F_OK):
434 msg = "No world config file from which to start a new world."
435 raise SystemExit(msg)
436 obey_lines_in_file(io_db["path_worldconf"], "world config ",
438 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
440 try_worldstate_update()
441 obey(read_command(), "in file", do_record=True)
445 """(Re-)make island map.
447 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
448 start with one land cell in the middle, then go into cycle of repeatedly
449 selecting a random sea cell and transforming it into land if it is neighbor
450 to land. The cycle ends when a land cell is due to be created at the map's
451 border. Then put some trees on the map (TODO: more precise algorithm desc).
453 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
455 def is_neighbor(coordinates, type):
458 length = world_db["MAP_LENGTH"]
460 diag_west = x + (ind > 0)
461 diag_east = x + (ind < (length - 1))
462 pos = (y * length) + x
463 if (y > 0 and diag_east
464 and type == chr(world_db["MAP"][pos - length + ind])) \
466 and type == chr(world_db["MAP"][pos + 1])) \
467 or (y < (length - 1) and diag_east
468 and type == chr(world_db["MAP"][pos + length + ind])) \
469 or (y > 0 and diag_west
470 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
472 and type == chr(world_db["MAP"][pos - 1])) \
473 or (y < (length - 1) and diag_west
474 and type == chr(world_db["MAP"][pos + length - (not ind)])):
478 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
479 length = world_db["MAP_LENGTH"]
480 add_half_width = (not (length % 2)) * int(length / 2)
481 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
483 y = rand.next() % length
484 x = rand.next() % length
485 pos = (y * length) + x
486 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
487 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
489 world_db["MAP"][pos] = ord(".")
490 n_trees = int((length ** 2) / 16)
492 while (i_trees <= n_trees):
493 single_allowed = rand.next() % 32
494 y = rand.next() % length
495 x = rand.next() % length
496 pos = (y * length) + x
497 if "." == chr(world_db["MAP"][pos]) \
498 and ((not single_allowed) or is_neighbor((y, x), "X")):
499 world_db["MAP"][pos] = ord("X")
501 # This all-too-precise replica of the original C code misses iter_limit().
502 n_colons = int((length ** 2) / 16) # #
504 while (i_colons <= n_colons): # #
505 single_allowed = rand.next() % 256 # #
506 y = rand.next() % length # #
507 x = rand.next() % length # #
508 pos = (y * length) + x # #
509 if ("." == chr(world_db["MAP"][pos]) # #
510 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
511 world_db["MAP"][pos] = ord(":") # #
513 altar_placed = False # #
514 while not altar_placed: # #
515 y = rand.next() % length # #
516 x = rand.next() % length # #
517 pos = (y * length) + x # #
518 if (("." == chr(world_db["MAP"][pos] # #
519 or ":" == chr(world_db["MAP"][pos]))
520 and not is_neighbor((y, x), "X"))): # #
521 world_db["MAP"][pos] = ord("_") # #
522 world_db["altar"] = (y, x) # #
523 altar_placed = True # #
526 def update_map_memory(t, age_map=True):
527 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
529 def age_some_memdepthmap_on_nonfov_cells():
530 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
534 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
535 # if not ord_v == t["fovmap"][pos]
536 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
537 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
538 # if not rand.next() % (2 **
539 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
540 # t["T_MEMDEPTHMAP"][pos] += 1
541 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
542 fovmap = c_pointer_to_bytearray(t["fovmap"])
543 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
545 if not t["T_MEMMAP"]:
546 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
547 if not t["T_MEMDEPTHMAP"]:
548 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
552 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
553 if ord_v == t["fovmap"][pos]]:
554 t["T_MEMDEPTHMAP"][pos] = ord_0
555 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
557 age_some_memdepthmap_on_nonfov_cells()
558 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
559 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
561 for id in [id for id in world_db["Things"]
562 if not world_db["Things"][id]["carried"]]:
563 type = world_db["Things"][id]["T_TYPE"]
564 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
565 y = world_db["Things"][id]["T_POSY"]
566 x = world_db["Things"][id]["T_POSX"]
567 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
568 t["T_MEMTHING"].append((type, y, x))
571 def set_world_inactive():
572 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
574 if os.access(io_db["path_worldstate"], os.F_OK):
575 os.remove(io_db["path_worldstate"])
576 world_db["WORLD_ACTIVE"] = 0
579 def integer_test(val_string, min, max=None):
580 """Return val_string if possible integer >= min and <= max, else None."""
582 val = int(val_string)
583 if val < min or (max is not None and val > max):
587 msg = "Ignoring: Please use integer >= " + str(min)
589 msg += " and <= " + str(max)
595 def setter(category, key, min, max=None):
596 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
599 val = integer_test(val_string, min, max)
603 if category == "Thing":
604 id_store = command_tid
605 decorator = test_Thing_id
606 elif category == "ThingType":
607 id_store = command_ttid
608 decorator = test_ThingType_id
609 elif category == "ThingAction":
610 id_store = command_taid
611 decorator = test_ThingAction_id
615 val = integer_test(val_string, min, max)
617 world_db[category + "s"][id_store.id][key] = val
621 def build_fov_map(t):
622 """Build Thing's FOV map."""
623 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
624 fovmap = c_pointer_to_bytearray(t["fovmap"])
625 map = c_pointer_to_bytearray(world_db["MAP"])
626 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
627 raise RuntimeError("Malloc error in build_fov_Map().")
631 """Send quick usage info to log."""
632 strong_write(io_db["file_out"], "LOG "
633 + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n")
634 strong_write(io_db["file_out"], "LOG "
635 + "Use 'p' to pick up objects, and 'D' to drop them.\n")
636 strong_write(io_db["file_out"], "LOG "
637 + "Some objects can be used (such as: eaten) by 'u' if "
638 + "they are in your inventory. "
639 + "Use 'Up'/'Down' to navigate the inventory.\n")
640 strong_write(io_db["file_out"], "LOG "
641 + "Use 'l' to toggle 'look' mode (move an exploration cursor "
642 + "instead of the player over the map).\n")
643 strong_write(io_db["file_out"], "LOG "
644 + "Use 'PgUp'/PgDn' to scroll the 'Things here' window.\n")
645 strong_write(io_db["file_out"], "LOG See README file for more details.\n")
648 def decrement_lifepoints(t):
649 """Decrement t's lifepoints by 1, and if to zero, corpse it.
651 If t is the player avatar, only blank its fovmap, so that the client may
652 still display memory data. On non-player things, erase fovmap and memory.
653 Dying actors drop all their things.
655 # 7DRL: Also decrements God's mood; deaths heavily so.
656 # 7DRL: Return 1 if death, else 0.
657 t["T_LIFEPOINTS"] -= 1
658 world_db["GOD_MOOD"] -= 1 # #
659 if 0 == t["T_LIFEPOINTS"]:
660 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
661 world_db["GOD_MOOD"] -= sadness # #
662 for id in t["T_CARRIES"]:
663 t["T_CARRIES"].remove(id)
664 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
665 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
666 world_db["Things"][id]["carried"] = False
667 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
668 if world_db["Things"][0] == t:
669 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
670 strong_write(io_db["file_out"], "LOG You die.\n")
671 strong_write(io_db["file_out"],
672 "LOG See README on how to start over.\n")
675 t["T_MEMMAP"] = False
676 t["T_MEMDEPTHMAP"] = False
682 def add_gods_favor(i): # #
683 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
684 def favor_multiplier(i):
686 threshold = math.e * x
687 mood = world_db["GOD_MOOD"]
690 i = i * math.log(mood / x)
691 elif -mood > threshold:
692 i = i / math.log(-mood / x)
694 if -mood > threshold:
695 i = i * math.log(-mood / x)
697 i = i / math.log(mood / x)
699 world_db["GOD_FAVOR"] += favor_multiplier(i)
702 def mv_yx_in_dir_legal(dir, y, x):
703 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
704 dir_c = dir.encode("ascii")[0]
705 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
707 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
708 return (test, libpr.result_y(), libpr.result_x())
711 def enter_altar(): # #
712 """What happens when the player enters the altar."""
713 if world_db["FAVOR_STAGE"] > 9000:
714 strong_write(io_db["file_out"],
715 "LOG You step on a soul-less slab of stone.\n")
717 strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
718 if world_db["FAVOR_STAGE"] == 0:
719 world_db["FAVOR_STAGE"] = 1
720 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
721 + "\"I don't trust you. You intrude on the island's "
722 + "affairs. I think you're a nuisance at best, and a "
723 + "danger to my children at worst. I will give you a "
724 + "chance to lighten my mood, however: For a while now, "
725 + "I've been trying to spread the plant "
726 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
728 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
729 + "\"). I have not been very successful so far. Maybe "
730 + "you can make yourself useful there. I will count "
732 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
733 + " that grows to your favor.\n")
734 elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
735 world_db["FAVOR_STAGE"] = 2
736 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
737 + "\"You could have done worse so far. Maybe you are not "
738 + "the worst to happen to this island since the metal "
739 + "birds threw the great lightning ball. Maybe you can "
740 + "help me spread another plant. It multiplies faster, "
741 + "and it is highly nutritious: "
742 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
744 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_SYMBOL"]
745 + "\"). It is new. I give you the only example. Be very "
746 + "careful with it! I also give you another tool that "
747 + "might be helpful.\n")
748 id = id_setter(-1, "Things")
749 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
751 id = id_setter(-1, "Things")
752 world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
754 elif world_db["FAVOR_STAGE"] == 2 and \
755 0 == len([id for id in world_db["Things"]
756 if world_db["Things"][id]["T_TYPE"]
757 == world_db["PLANT_1"]]):
758 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
759 + "\"I am greatly disappointed that you lost all "
760 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
761 + " this island had. Here is another one. It cost me "
762 + " great work. Be more careful this time.\n")
763 id = id_setter(-1, "Things")
764 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
767 elif world_db["GOD_FAVOR"] > 9000:
768 world_db["FAVOR_STAGE"] = 9001
769 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
770 + "\"You have proven yourself worthy of my respect. "
771 + "You were a good citizen to the island, and sometimes "
772 + "a better steward to its inhabitants than me. The "
773 + "island shall miss you when you leave. But you have "
774 + "earned the right to do so. Take this "
775 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
776 + " and USE it when you please. It will take you to "
777 + "where you came from. (But do feel free to stay here "
778 + "as long as you like.)\"\n")
779 id = id_setter(-1, "Things")
780 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
785 """Make t do nothing (but loudly, if player avatar)."""
786 if t == world_db["Things"][0]:
787 strong_write(io_db["file_out"], "LOG You wait.\n")
791 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
792 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
793 # 7DRL: Player entering the altar triggers enter_altar().
794 # 7DRL: Player with axe chops down trees.
796 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
797 t["T_POSY"], t["T_POSX"])
798 if 1 == move_result[0]:
799 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
800 hitted = [id for id in world_db["Things"]
801 if world_db["Things"][id] != t
802 if world_db["Things"][id]["T_LIFEPOINTS"]
803 if world_db["Things"][id]["T_POSY"] == move_result[1]
804 if world_db["Things"][id]["T_POSX"] == move_result[2]]
807 if t == world_db["Things"][0]:
808 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
809 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
810 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
812 add_gods_favor(-1) # #
814 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
815 strong_write(io_db["file_out"], "LOG " + hitter_name +
817 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
818 if test and t == world_db["Things"][0]: # #
819 add_gods_favor(-test) # #
821 if (ord("X") == world_db["MAP"][pos] # #
822 or ord("|") == world_db["MAP"][pos]): # #
823 carries_axe = False # #
824 for id in t["T_CARRIES"]: # #
825 type = world_db["Things"][id]["T_TYPE"] # #
826 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # #
827 carries_axe = True # #
830 axe_name = world_db["ThingTypes"][type]["TT_NAME"] # #
831 if t == world_db["Things"][0]: # #
832 strong_write(io_db["file_out"], "LOG With your " # #
834 + ", you chop!\n") # #
835 if ord("X") == world_db["MAP"][pos]: # #
836 add_gods_favor(-1) # #
837 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
838 case_X = world_db["MAP"][pos] == ord("X") # #
839 if (chop_power > 0 # #
841 0 == int(rand.next() / chop_power)) # #
842 or (not case_X and # #
843 0 == int(rand.next() / (3 * chop_power))))): # #
844 if t == world_db["Things"][0]: # #
845 strong_write(io_db["file_out"], # #
846 "LOG You chop it down.\n") # #
847 if world_db["MAP"][pos] == ord("X"): # #
848 add_gods_favor(-10) # #
849 world_db["MAP"][pos] = ord(".") # #
850 i = 3 if case_X else 1 # #
851 for i in range(i): # #
852 id = id_setter(-1, "Things") # #
853 world_db["Things"][id] = \
854 new_Thing(world_db["LUMBER"], # #
855 (move_result[1], move_result[2])) # #
858 passable = ("." == chr(world_db["MAP"][pos]) or
859 ":" == chr(world_db["MAP"][pos]) or # #
860 "_" == chr(world_db["MAP"][pos])) # #
861 dir = [dir for dir in directions_db
862 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
864 t["T_POSY"] = move_result[1]
865 t["T_POSX"] = move_result[2]
866 for id in t["T_CARRIES"]:
867 world_db["Things"][id]["T_POSY"] = move_result[1]
868 world_db["Things"][id]["T_POSX"] = move_result[2]
870 if t == world_db["Things"][0]:
871 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
872 if (move_result[1] == world_db["altar"][0] and # #
873 move_result[2] == world_db["altar"][1]): # #
875 elif t == world_db["Things"][0]:
876 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
879 def actor_pick_up(t):
880 """Make t pick up (topmost?) Thing from ground into inventory.
882 Define topmostness by how low the thing's type ID is.
884 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
885 used_slots = len(t["T_CARRIES"]) # #
886 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
887 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
888 if not world_db["Things"][id]["carried"]
889 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
890 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
894 tid = world_db["Things"][iid]["T_TYPE"]
895 if lowest_tid == -1 or tid < lowest_tid:
898 world_db["Things"][id]["carried"] = True
899 type = world_db["Things"][id]["T_TYPE"] # #
900 if (t != world_db["Things"][0] # #
901 and world_db["Things"][id]["T_PLAYERDROP"] # #
902 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # #
903 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # #
904 add_gods_favor(score) # #
905 world_db["Things"][id]["T_PLAYERDROP"] = 0 # #
906 t["T_CARRIES"].append(id)
907 if t == world_db["Things"][0]:
908 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
909 elif t == world_db["Things"][0]:
910 err = "You try to pick up an object, but there is none."
911 strong_write(io_db["file_out"], "LOG " + err + "\n")
912 elif t == world_db["Things"][0]: # #
913 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
914 "No storage room to carry more.\n") # #
918 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
919 # TODO: Handle case where T_ARGUMENT matches nothing.
920 if len(t["T_CARRIES"]):
921 id = t["T_CARRIES"][t["T_ARGUMENT"]]
922 t["T_CARRIES"].remove(id)
923 world_db["Things"][id]["carried"] = False
924 if t == world_db["Things"][0]:
925 strong_write(io_db["file_out"], "LOG You drop an object.\n")
926 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
927 elif t == world_db["Things"][0]:
928 err = "You try to drop an object, but you own none."
929 strong_write(io_db["file_out"], "LOG " + err + "\n")
933 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
934 # TODO: Handle case where T_ARGUMENT matches nothing.
935 # 7DLR: Handle SLIPPERS-type Thing use.
936 if len(t["T_CARRIES"]):
937 id = t["T_CARRIES"][t["T_ARGUMENT"]]
938 type = world_db["Things"][id]["T_TYPE"]
939 if type == world_db["SLIPPERS"]: # #
940 if t == world_db["Things"][0]: # #
941 strong_write(io_db["file_out"], "LOG You use the " # #
942 + world_db["ThingTypes"][type]["TT_NAME"] # #
943 + ". It glows in wondrous colors, and emits " # #
944 + "a sound as if from a dying cat. The " # #
945 + "Island God laughs.\n") # #
946 t["T_LIFEPOINTS"] = 1 # #
947 decrement_lifepoints(t) # #
948 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # #
949 and t == world_db["Things"][0]): # #
950 strong_write(io_db["file_out"], # #
951 "LOG To use this item for chopping, move " # #
952 "towards a tree while carrying it in " # #
953 "your inventory.\n") # #
954 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"): # #
955 pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
956 if (world_db["MAP"][pos] == ord("X") # #
957 or world_db["MAP"][pos] == ord("|")): # #
958 strong_write(io_db["file_out"], # #
959 "LOG Can't build when standing on barrier.\n") # #
961 for id in [id for id in world_db["Things"]
962 if not world_db["Things"][id] == t
963 if not world_db["Things"][id]["carried"]
964 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
965 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
966 strong_write(io_db["file_out"],
967 "LOG Can't build when standing objects.\n") # #
969 for id in t["T_CARRIES"]: # #
970 type_tool = world_db["Things"][id]["T_TYPE"] # #
971 if (world_db["ThingTypes"][type_tool]["TT_TOOL"] # #
975 for id in t["T_CARRIES"]: # #
976 type_material = world_db["Things"][id]["T_TYPE"] # #
977 if (world_db["ThingTypes"][type_material]["TT_TOOL"] # #
981 if wood_id != None: # #
982 t["T_CARRIES"].remove(wood_id) # #
983 del world_db["Things"][wood_id] # #
984 world_db["MAP"][pos] = ord("|") # #
985 strong_write(io_db["file_out"], "LOG With your " # #
986 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
987 + " you build a wooden barrier from your " # #
988 + world_db["ThingTypes"][type_material] # #
992 strong_write(io_db["file_out"], "LOG You can't use a " # #
993 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
994 + " without some wood in your inventory.\n") # #
995 elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
996 t["T_CARRIES"].remove(id)
997 del world_db["Things"][id]
998 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
999 if t == world_db["Things"][0]:
1000 strong_write(io_db["file_out"],
1001 "LOG You consume this object.\n")
1002 elif t == world_db["Things"][0]:
1003 strong_write(io_db["file_out"],
1004 "LOG You try to use this object, but fail.\n")
1005 elif t == world_db["Things"][0]:
1006 strong_write(io_db["file_out"],
1007 "LOG You try to use an object, but you own none.\n")
1010 def thingproliferation(t, prol_map):
1011 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1013 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1014 marked "." in prol_map. If there are several map cell candidates, one is
1017 # 7DRL: success increments God's mood
1018 # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1019 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1020 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1022 for dir in [directions_db[key] for key in directions_db]:
1023 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1024 pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1025 if mv_result[0] and \
1026 (ord(":") == prol_map[pos] # #
1027 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1028 and ord(".") == prol_map[pos])):
1029 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1030 # * world_db["MAP_LENGTH"]
1032 candidates.append((mv_result[1], mv_result[2]))
1034 i = rand.next() % len(candidates)
1035 id = id_setter(-1, "Things")
1036 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1037 world_db["Things"][id] = newT
1038 animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1040 world_db["GOD_MOOD"] += animacy # #
1042 world_db["GOD_MOOD"] += 1 # #
1043 if (world_db["FAVOR_STAGE"] > 0 # #
1044 and t["T_TYPE"] == world_db["PLANT_0"]): # #
1045 world_db["GOD_FAVOR"] += 5 # #
1046 elif t["T_TYPE"] == world_db["PLANT_1"]: # #
1047 world_db["GOD_FAVOR"] += 25 # #
1051 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
1053 On success, decrease satiation score by 32.
1055 # 7DRL: Successful heals increment God's mood.
1056 if t["T_SATIATION"] > 0 \
1057 and t["T_LIFEPOINTS"] < \
1058 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
1059 and 0 == (rand.next() % 31) \
1060 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
1061 if world_db["ThingActions"][id]["TA_NAME"] ==
1063 t["T_LIFEPOINTS"] += 1
1064 world_db["GOD_MOOD"] += 1 # #
1065 t["T_SATIATION"] -= 32
1066 if t == world_db["Things"][0]:
1067 strong_write(io_db["file_out"], "LOG You heal.\n")
1071 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1072 if t["T_SATIATION"] > -32768:
1073 t["T_SATIATION"] -= 1
1074 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
1075 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1076 raise RuntimeError("A thing that should not hunger is hungering.")
1077 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
1078 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
1079 if t == world_db["Things"][0]:
1080 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
1081 decrement_lifepoints(t)
1084 def get_dir_to_target(t, filter):
1085 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1087 The path-wise nearest target is chosen, via the shortest available path.
1088 Target must not be t. On succcess, return positive value, else False.
1090 "a": Thing in FOV is below a certain distance, animate, but of ThingType
1091 that is not t's, and starts out weaker than t is; build path as
1092 avoiding things of t's ThingType
1093 "f": neighbor cell (not inhabited by any animate Thing) further away from
1094 animate Thing not further than x steps away and in FOV and of a
1095 ThingType that is not t's, and starts out stronger or as strong as t
1096 is currently; or (cornered), if no such flight cell, but Thing of
1097 above criteria is too near,1 a cell closer to it, or, if less near,
1099 "c": Thing in memorized map is consumable
1100 "s": memory map cell with greatest-reachable degree of unexploredness
1103 def zero_score_map_where_char_on_memdepthmap(c):
1104 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1105 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1106 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1107 # set_map_score(i, 0)
1108 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1109 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1110 raise RuntimeError("No score map allocated for "
1111 "zero_score_map_where_char_on_memdepthmap().")
1113 def set_map_score(pos, score):
1114 test = libpr.set_map_score(pos, score)
1116 raise RuntimeError("No score map allocated for set_map_score().")
1118 def get_map_score(pos):
1119 result = libpr.get_map_score(pos)
1121 raise RuntimeError("No score map allocated for get_map_score().")
1125 if t["fovmap"] and ("a" == filter or "f" == filter):
1126 for id in world_db["Things"]:
1127 Thing = world_db["Things"][id]
1128 if Thing != t and Thing["T_LIFEPOINTS"] and \
1129 t["T_TYPE"] != Thing["T_TYPE"] and \
1130 'v' == chr(t["fovmap"][(Thing["T_POSY"]
1131 * world_db["MAP_LENGTH"])
1132 + Thing["T_POSX"]]):
1133 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1134 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1135 t["T_LIFEPOINTS"]) \
1136 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1139 elif t["T_MEMMAP"] and "c" == filter:
1140 for mt in t["T_MEMTHING"]:
1141 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1143 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1147 def set_cells_passable_on_memmap_to_65534_on_scoremap():
1148 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1149 # ord_dot = ord(".")
1150 # memmap = t["T_MEMMAP"]
1151 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1152 # if ord_dot == memmap[i]]:
1153 # set_map_score(i, 65534) # i.e. 65535-1
1154 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1155 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1156 raise RuntimeError("No score map allocated for "
1157 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1159 def init_score_map():
1160 test = libpr.init_score_map()
1162 raise RuntimeError("Malloc error in init_score_map().")
1164 ord_blank = ord(" ")
1165 set_cells_passable_on_memmap_to_65534_on_scoremap()
1167 for id in world_db["Things"]:
1168 Thing = world_db["Things"][id]
1169 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1171 if t != Thing and Thing["T_LIFEPOINTS"] and \
1172 t["T_TYPE"] != Thing["T_TYPE"] and \
1173 ord_v == t["fovmap"][pos] and \
1174 t["T_LIFEPOINTS"] > \
1175 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1176 set_map_score(pos, 0)
1177 elif t["T_TYPE"] == Thing["T_TYPE"]:
1178 set_map_score(pos, 65535)
1180 for id in [id for id in world_db["Things"]
1181 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1182 Thing = world_db["Things"][id]
1183 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1185 if t["T_TYPE"] != Thing["T_TYPE"] and \
1186 ord_v == t["fovmap"][pos] and \
1187 t["T_LIFEPOINTS"] <= \
1188 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1189 set_map_score(pos, 0)
1191 for mt in [mt for mt in t["T_MEMTHING"]
1192 if ord_blank != t["T_MEMMAP"][mt[1]
1193 * world_db["MAP_LENGTH"]
1195 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1196 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1198 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1200 def rand_target_dir(neighbors, cmp, dirs):
1203 for i in range(len(dirs)):
1204 if cmp == neighbors[i]:
1205 candidates.append(dirs[i])
1207 return candidates[rand.next() % n_candidates] if n_candidates else 0
1209 def get_neighbor_scores(dirs, eye_pos):
1211 if libpr.ready_neighbor_scores(eye_pos):
1212 raise RuntimeError("No score map allocated for " +
1213 "ready_neighbor_scores.()")
1214 for i in range(len(dirs)):
1215 scores.append(libpr.get_neighbor_score(i))
1218 def get_dir_from_neighbors():
1219 dir_to_target = False
1221 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1222 neighbors = get_neighbor_scores(dirs, eye_pos)
1224 inhabited = [world_db["Things"][id]["T_POSY"]
1225 * world_db["MAP_LENGTH"]
1226 + world_db["Things"][id]["T_POSX"]
1227 for id in world_db["Things"]
1228 if world_db["Things"][id]["T_LIFEPOINTS"]]
1229 for i in range(len(dirs)):
1230 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1231 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1233 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1234 neighbors[i] = 65535
1236 minmax_start = 0 if "f" == filter else 65535 - 1
1237 minmax_neighbor = minmax_start
1238 for i in range(len(dirs)):
1239 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1240 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1241 or ("f" != filter and minmax_neighbor > neighbors[i]):
1242 minmax_neighbor = neighbors[i]
1243 if minmax_neighbor != minmax_start:
1244 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1246 if not dir_to_target:
1247 if 1 == get_map_score(eye_pos):
1248 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1249 elif 3 >= get_map_score(eye_pos):
1250 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1252 world_db["ThingActions"][id]["TA_NAME"]
1255 elif dir_to_target and 3 < get_map_score(eye_pos):
1257 elif "a" == filter and 10 <= get_map_score(eye_pos):
1259 return dir_to_target
1261 dir_to_target = False
1263 run_i = 9 + 1 if "s" == filter else 1
1264 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1267 mem_depth_c = b'9' if b' ' == mem_depth_c \
1268 else bytes([mem_depth_c[0] - 1])
1269 if libpr.dijkstra_map():
1270 raise RuntimeError("No score map allocated for dijkstra_map().")
1271 dir_to_target = get_dir_from_neighbors()
1272 libpr.free_score_map()
1273 if dir_to_target and str == type(dir_to_target):
1274 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1275 if world_db["ThingActions"][id]["TA_NAME"]
1277 t["T_ARGUMENT"] = ord(dir_to_target)
1278 return dir_to_target
1281 def standing_on_food(t):
1282 """Return True/False whether t is standing on a consumable."""
1283 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1284 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1285 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1286 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1287 ["TT_TOOL"] == "food"]:
1292 def get_inventory_slot_to_consume(t):
1293 """Return slot Id of strongest consumable in t's inventory, else -1."""
1297 for id in t["T_CARRIES"]:
1298 type = world_db["Things"][id]["T_TYPE"]
1299 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1300 and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > cmp_food:
1301 cmp_food = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1308 """Determine next command/argment for actor t via AI algorithms.
1310 AI will look for, and move towards, enemies (animate Things not of their
1311 own ThingType); if they see none, they will consume consumables in their
1312 inventory; if there are none, they will pick up what they stand on if they
1313 stand on consumables; if they stand on none, they will move towards the
1314 next consumable they see or remember on the map; if they see or remember
1315 none, they will explore parts of the map unseen since ever or for at least
1316 one turn; if there is nothing to explore, they will simply wait.
1318 # 7DRL add: Don't pick up or search things when inventory is full.
1319 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1320 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1321 if not get_dir_to_target(t, "f"):
1322 sel = get_inventory_slot_to_consume(t)
1324 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1325 if world_db["ThingActions"][id]["TA_NAME"]
1327 t["T_ARGUMENT"] = sel
1328 elif standing_on_food(t) \
1329 and (len(t["T_CARRIES"]) < # #
1330 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1331 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1332 if world_db["ThingActions"][id]["TA_NAME"]
1335 (len(t["T_CARRIES"]) < # #
1336 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1337 and get_dir_to_target(t, "c"))) and \
1338 (not get_dir_to_target(t, "a")):
1339 get_dir_to_target(t, "s")
1343 """Run game world and its inhabitants until new player input expected."""
1345 whilebreaker = False
1346 while world_db["Things"][0]["T_LIFEPOINTS"]:
1347 proliferable_map = world_db["MAP"][:]
1348 for id in [id for id in world_db["Things"]
1349 if not world_db["Things"][id]["carried"]]:
1350 y = world_db["Things"][id]["T_POSY"]
1351 x = world_db["Things"][id]["T_POSX"]
1352 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1353 for id in [id for id in world_db["Things"]]: # Only what's from start!
1354 if not id in world_db["Things"] or \
1355 world_db["Things"][id]["carried"]: # May have been consumed or
1356 continue # picked up during turn …
1357 Thing = world_db["Things"][id]
1358 if Thing["T_LIFEPOINTS"]:
1359 if not Thing["T_COMMAND"]:
1360 update_map_memory(Thing)
1367 if Thing["T_LIFEPOINTS"]:
1368 Thing["T_PROGRESS"] += 1
1369 taid = [a for a in world_db["ThingActions"]
1370 if a == Thing["T_COMMAND"]][0]
1371 ThingAction = world_db["ThingActions"][taid]
1372 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1373 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1374 Thing["T_COMMAND"] = 0
1375 Thing["T_PROGRESS"] = 0
1376 thingproliferation(Thing, proliferable_map)
1379 world_db["TURN"] += 1
1382 def new_Thing(type, pos=(0, 0)):
1383 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1385 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1390 "T_PLAYERDROP": 0, # #
1398 "T_MEMDEPTHMAP": False,
1401 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1402 build_fov_map(thing)
1406 def id_setter(id, category, id_store=False, start_at_1=False):
1407 """Set ID of object of category to manipulate ID unused? Create new one.
1409 The ID is stored as id_store.id (if id_store is set). If the integer of the
1410 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1411 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1412 always returned when no new object is created, otherwise the new object's
1415 min = 0 if start_at_1 else -1
1417 id = integer_test(id, min)
1419 if id in world_db[category]:
1424 if (start_at_1 and 0 == id) \
1425 or ((not start_at_1) and (id < 0)):
1426 id = 0 if start_at_1 else -1
1429 if id not in world_db[category]:
1437 """Send PONG line to server output file."""
1438 strong_write(io_db["file_out"], "PONG\n")
1442 """Abort server process."""
1443 if None == opts.replay:
1444 if world_db["WORLD_ACTIVE"]:
1446 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1447 raise SystemExit("received QUIT command")
1450 def command_thingshere(str_y, str_x):
1451 """Write to out file list of Things known to player at coordinate y, x."""
1452 # 7DRL: terrain, too
1453 if world_db["WORLD_ACTIVE"]:
1454 y = integer_test(str_y, 0, 255)
1455 x = integer_test(str_x, 0, 255)
1456 length = world_db["MAP_LENGTH"]
1457 if None != y and None != x and y < length and x < length:
1458 pos = (y * world_db["MAP_LENGTH"]) + x
1459 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1460 pos = y * world_db["MAP_LENGTH"] + x; # #
1461 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1462 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1463 for id in world_db["Things"]
1464 if not world_db["Things"][id]["carried"]
1465 if world_db["Things"][id]["T_TYPE"] == tid
1466 if y == world_db["Things"][id]["T_POSY"]
1467 if x == world_db["Things"][id]["T_POSX"]]:
1468 type = world_db["Things"][id]["T_TYPE"]
1469 name = world_db["ThingTypes"][type]["TT_NAME"]
1470 strong_write(io_db["file_out"], name + "\n")
1472 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1473 for mt in world_db["Things"][0]["T_MEMTHING"]
1474 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1475 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1476 strong_write(io_db["file_out"], name + "\n")
1477 if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"): # #
1478 name = "(terrain: SEA)" # #
1479 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."): # #
1480 name = "(terrain: EARTH)" # #
1481 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"): # #
1482 name = "(terrain: SOIL)" # #
1483 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"): # #
1484 name = "(terrain: TREE)" # #
1485 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"): # #
1486 name = "(terrain: WALL)" # #
1487 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"): # #
1488 name = "(terrain: ALTAR)" # #
1491 strong_write(io_db["file_out"], name + "\n") # #
1492 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1494 print("Ignoring: Invalid map coordinates.")
1496 print("Ignoring: Command only works on existing worlds.")
1499 def play_commander(action, args=False):
1500 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1502 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1506 id = [x for x in world_db["ThingActions"]
1507 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1508 world_db["Things"][0]["T_COMMAND"] = id
1511 def set_command_and_argument_int(str_arg):
1512 val = integer_test(str_arg, 0, 255)
1514 world_db["Things"][0]["T_ARGUMENT"] = val
1517 def set_command_and_argument_movestring(str_arg):
1518 if str_arg in directions_db:
1519 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1522 print("Ignoring: Argument must be valid direction string.")
1524 if action == "move":
1525 return set_command_and_argument_movestring
1527 return set_command_and_argument_int
1532 def command_seedrandomness(seed_string):
1533 """Set rand seed to int(seed_string)."""
1534 val = integer_test(seed_string, 0, 4294967295)
1539 def command_makeworld(seed_string):
1540 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1542 Seed rand with seed. Do more only with a "wait" ThingAction and
1543 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1544 world_db["Things"] emptied, call make_map() and set
1545 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1546 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1547 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1548 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1552 # def free_pos(plant=False):
1553 def free_pos(plant=False): # #
1556 err = "Space to put thing on too hard to find. Map too small?"
1558 y = rand.next() % world_db["MAP_LENGTH"]
1559 x = rand.next() % world_db["MAP_LENGTH"]
1560 pos = y * world_db["MAP_LENGTH"] + x;
1562 and "." == chr(world_db["MAP"][pos])) \
1563 or ":" == chr(world_db["MAP"][pos]): # #
1567 raise SystemExit(err)
1568 # Replica of C code, wrongly ignores animatedness of new Thing.
1569 pos_clear = (0 == len([id for id in world_db["Things"]
1570 if world_db["Things"][id]["T_LIFEPOINTS"]
1571 if world_db["Things"][id]["T_POSY"] == y
1572 if world_db["Things"][id]["T_POSX"] == x]))
1577 val = integer_test(seed_string, 0, 4294967295)
1581 player_will_be_generated = False
1582 playertype = world_db["PLAYER_TYPE"]
1583 for ThingType in world_db["ThingTypes"]:
1584 if playertype == ThingType:
1585 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1586 player_will_be_generated = True
1588 if not player_will_be_generated:
1589 print("Ignoring: No player type with start number >0 defined.")
1592 for ThingAction in world_db["ThingActions"]:
1593 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1596 print("Ignoring: No thing action with name 'wait' defined.")
1598 for name in specials: # #
1599 if world_db[name] not in world_db["ThingTypes"]: # #
1600 print("Ignoring: No valid " + name + " set.") # #
1602 world_db["Things"] = {}
1604 world_db["WORLD_ACTIVE"] = 1
1605 world_db["TURN"] = 1
1606 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1607 id = id_setter(-1, "Things")
1608 world_db["Things"][id] = new_Thing(playertype, free_pos())
1609 if not world_db["Things"][0]["fovmap"]:
1610 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1611 world_db["Things"][0]["fovmap"] = empty_fovmap
1612 update_map_memory(world_db["Things"][0])
1613 for type in world_db["ThingTypes"]:
1614 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1615 if type != playertype:
1616 id = id_setter(-1, "Things")
1617 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1618 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1619 strong_write(io_db["file_out"], "NEW_WORLD\n")
1623 def command_maplength(maplength_string):
1624 """Redefine map length. Invalidate map, therefore lose all things on it."""
1625 val = integer_test(maplength_string, 1, 256)
1627 world_db["MAP_LENGTH"] = val
1628 world_db["MAP"] = False
1629 set_world_inactive()
1630 world_db["Things"] = {}
1631 libpr.set_maplength(val)
1634 def command_worldactive(worldactive_string):
1635 """Toggle world_db["WORLD_ACTIVE"] if possible.
1637 An active world can always be set inactive. An inactive world can only be
1638 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1639 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1640 Also call log_help().
1642 # 7DRL: altar must be on map, and specials must be set for active world.
1643 val = integer_test(worldactive_string, 0, 1)
1645 if 0 != world_db["WORLD_ACTIVE"]:
1647 set_world_inactive()
1649 print("World already active.")
1650 elif 0 == world_db["WORLD_ACTIVE"]:
1652 for ThingAction in world_db["ThingActions"]:
1653 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1656 player_exists = False
1657 for Thing in world_db["Things"]:
1659 player_exists = True
1661 specials_set = True # #
1662 for name in specials: # #
1663 if world_db[name] not in world_db["ThingTypes"]: # #
1664 specials_set = False # #
1665 altar_found = False # #
1666 if world_db["MAP"]: # #
1667 pos = world_db["MAP"].find(b'_') # #
1669 y = int(pos / world_db["MAP_LENGTH"]) # #
1670 x = pos % world_db["MAP_LENGTH"] # #
1671 world_db["altar"] = (y, x) # #
1672 altar_found = True # #
1673 if wait_exists and player_exists and world_db["MAP"] \
1674 and specials_set: # #
1675 for id in world_db["Things"]:
1676 if world_db["Things"][id]["T_LIFEPOINTS"]:
1677 build_fov_map(world_db["Things"][id])
1679 update_map_memory(world_db["Things"][id], False)
1680 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1681 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1682 world_db["Things"][0]["fovmap"] = empty_fovmap
1683 world_db["WORLD_ACTIVE"] = 1
1686 print("Ignoring: Not all conditions for world activation met.")
1689 def specialtypesetter(name): # #
1690 """Setter world_db[name], deactivating world if set int no ThingType."""
1691 def helper(str_int):
1692 val = integer_test(str_int, 0)
1694 world_db[name] = val
1695 if world_db["WORLD_ACTIVE"] \
1696 and world_db[name] not in world_db["ThingTypes"]:
1697 world_db["WORLD_ACTIVE"] = 0
1698 print(name + " fits no known ThingType, deactivating world.")
1702 def test_for_id_maker(object, category):
1703 """Return decorator testing for object having "id" attribute."""
1706 if hasattr(object, "id"):
1709 print("Ignoring: No " + category +
1710 " defined to manipulate yet.")
1715 def command_tid(id_string):
1716 """Set ID of Thing to manipulate. ID unused? Create new one.
1718 Default new Thing's type to the first available ThingType, others: zero.
1720 id = id_setter(id_string, "Things", command_tid)
1722 if world_db["ThingTypes"] == {}:
1723 print("Ignoring: No ThingType to settle new Thing in.")
1725 type = list(world_db["ThingTypes"].keys())[0]
1726 world_db["Things"][id] = new_Thing(type)
1729 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1733 def command_tcommand(str_int):
1734 """Set T_COMMAND of selected Thing."""
1735 val = integer_test(str_int, 0)
1737 if 0 == val or val in world_db["ThingActions"]:
1738 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1740 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1744 def command_ttype(str_int):
1745 """Set T_TYPE of selected Thing."""
1746 val = integer_test(str_int, 0)
1748 if val in world_db["ThingTypes"]:
1749 world_db["Things"][command_tid.id]["T_TYPE"] = val
1751 print("Ignoring: ThingType ID belongs to no known ThingType.")
1755 def command_tcarries(str_int):
1756 """Append int(str_int) to T_CARRIES of selected Thing.
1758 The ID int(str_int) must not be of the selected Thing, and must belong to a
1759 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1761 val = integer_test(str_int, 0)
1763 if val == command_tid.id:
1764 print("Ignoring: Thing cannot carry itself.")
1765 elif val in world_db["Things"] \
1766 and not world_db["Things"][val]["carried"]:
1767 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1768 world_db["Things"][val]["carried"] = True
1770 print("Ignoring: Thing not available for carrying.")
1771 # Note that the whole carrying structure is different from the C version:
1772 # Carried-ness is marked by a "carried" flag, not by Things containing
1773 # Things internally.
1777 def command_tmemthing(str_t, str_y, str_x):
1778 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1780 The type must fit to an existing ThingType, and the position into the map.
1782 type = integer_test(str_t, 0)
1783 posy = integer_test(str_y, 0, 255)
1784 posx = integer_test(str_x, 0, 255)
1785 if None != type and None != posy and None != posx:
1786 if type not in world_db["ThingTypes"] \
1787 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1788 print("Ignoring: Illegal value for thing type or position.")
1790 memthing = (type, posy, posx)
1791 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1794 def setter_map(maptype):
1795 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1797 If no map of maptype exists yet, initialize it with ' ' bytes first.
1800 def valid_map_line(str_int, mapline):
1801 val = integer_test(str_int, 0, 255)
1803 if val >= world_db["MAP_LENGTH"]:
1804 print("Illegal value for map line number.")
1805 elif len(mapline) != world_db["MAP_LENGTH"]:
1806 print("Map line length is unequal map width.")
1811 def nonThingMap_helper(str_int, mapline):
1812 val = valid_map_line(str_int, mapline)
1814 length = world_db["MAP_LENGTH"]
1815 if not world_db["MAP"]:
1816 map = bytearray(b' ' * (length ** 2))
1818 map = world_db["MAP"]
1819 map[val * length:(val * length) + length] = mapline.encode()
1820 if not world_db["MAP"]:
1821 world_db["MAP"] = map
1824 def ThingMap_helper(str_int, mapline):
1825 val = valid_map_line(str_int, mapline)
1827 length = world_db["MAP_LENGTH"]
1828 if not world_db["Things"][command_tid.id][maptype]:
1829 map = bytearray(b' ' * (length ** 2))
1831 map = world_db["Things"][command_tid.id][maptype]
1832 map[val * length:(val * length) + length] = mapline.encode()
1833 if not world_db["Things"][command_tid.id][maptype]:
1834 world_db["Things"][command_tid.id][maptype] = map
1836 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1839 def setter_tpos(axis):
1840 """Generate setter for T_POSX or T_POSY of selected Thing.
1842 If world is active, rebuilds animate things' fovmap, player's memory map.
1845 def helper(str_int):
1846 val = integer_test(str_int, 0, 255)
1848 if val < world_db["MAP_LENGTH"]:
1849 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1850 if world_db["WORLD_ACTIVE"] \
1851 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1852 build_fov_map(world_db["Things"][command_tid.id])
1853 if 0 == command_tid.id:
1854 update_map_memory(world_db["Things"][command_tid.id])
1856 print("Ignoring: Position is outside of map.")
1860 def command_ttid(id_string):
1861 """Set ID of ThingType to manipulate. ID unused? Create new one.
1863 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1866 id = id_setter(id_string, "ThingTypes", command_ttid)
1868 world_db["ThingTypes"][id] = {
1869 "TT_NAME": "(none)",
1872 "TT_PROLIFERATE": 0,
1873 "TT_START_NUMBER": 0,
1874 "TT_STORAGE": 0, # #
1881 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1885 def command_ttname(name):
1886 """Set TT_NAME of selected ThingType."""
1887 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1891 def command_tttool(name):
1892 """Set TT_TOOL of selected ThingType."""
1893 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1897 def command_ttsymbol(char):
1898 """Set TT_SYMBOL of selected ThingType. """
1900 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1902 print("Ignoring: Argument must be single character.")
1906 def command_ttcorpseid(str_int):
1907 """Set TT_CORPSE_ID of selected ThingType."""
1908 val = integer_test(str_int, 0)
1910 if val in world_db["ThingTypes"]:
1911 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1913 print("Ignoring: Corpse ID belongs to no known ThignType.")
1916 def command_taid(id_string):
1917 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1919 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1921 id = id_setter(id_string, "ThingActions", command_taid, True)
1923 world_db["ThingActions"][id] = {
1929 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1932 @test_ThingAction_id
1933 def command_taname(name):
1934 """Set TA_NAME of selected ThingAction.
1936 The name must match a valid thing action function. If after the name
1937 setting no ThingAction with name "wait" remains, call set_world_inactive().
1939 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1940 or name == "pick_up":
1941 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1942 if 1 == world_db["WORLD_ACTIVE"]:
1943 wait_defined = False
1944 for id in world_db["ThingActions"]:
1945 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1948 if not wait_defined:
1949 set_world_inactive()
1951 print("Ignoring: Invalid action name.")
1952 # In contrast to the original,naming won't map a function to a ThingAction.
1956 """Call ai() on player Thing, then turn_over()."""
1957 ai(world_db["Things"][0])
1961 """Commands database.
1963 Map command start tokens to ([0]) number of expected command arguments, ([1])
1964 the command's meta-ness (i.e. is it to be written to the record file, is it to
1965 be ignored in replay mode if read from server input file), and ([2]) a function
1969 "QUIT": (0, True, command_quit),
1970 "PING": (0, True, command_ping),
1971 "THINGS_HERE": (2, True, command_thingshere),
1972 "MAKE_WORLD": (1, False, command_makeworld),
1973 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1974 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1975 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1976 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1977 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1978 "MAP_LENGTH": (1, False, command_maplength),
1979 "WORLD_ACTIVE": (1, False, command_worldactive),
1980 "MAP": (2, False, setter_map("MAP")),
1981 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
1982 "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")), # #
1983 "PLANT_0": (1, False, specialtypesetter("PLANT_0")), # #
1984 "PLANT_1": (1, False, specialtypesetter("PLANT_1")), # #
1985 "LUMBER": (1, False, specialtypesetter("LUMBER")), # #
1986 "TOOL_0": (1, False, specialtypesetter("TOOL_0")), # #
1987 "TA_ID": (1, False, command_taid),
1988 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1989 "TA_NAME": (1, False, command_taname),
1990 "TT_ID": (1, False, command_ttid),
1991 "TT_NAME": (1, False, command_ttname),
1992 "TT_TOOL": (1, False, command_tttool),
1993 "TT_SYMBOL": (1, False, command_ttsymbol),
1994 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1995 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1996 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1998 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2000 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2001 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
2002 "T_ID": (1, False, command_tid),
2003 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2004 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2005 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2006 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2007 "T_COMMAND": (1, False, command_tcommand),
2008 "T_TYPE": (1, False, command_ttype),
2009 "T_CARRIES": (1, False, command_tcarries),
2010 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2011 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2012 "T_MEMTHING": (3, False, command_tmemthing),
2013 "T_POSY": (1, False, setter_tpos("Y")),
2014 "T_POSX": (1, False, setter_tpos("X")),
2015 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
2016 "wait": (0, False, play_commander("wait")),
2017 "move": (1, False, play_commander("move")),
2018 "pick_up": (0, False, play_commander("pick_up")),
2019 "drop": (1, False, play_commander("drop", True)),
2020 "use": (1, False, play_commander("use", True)),
2021 "ai": (0, False, command_ai)
2023 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2026 """World state database. With sane default values. (Randomness is in rand.)"""
2035 "FAVOR_STAGE": 0, # #
2047 """Special type settings."""
2048 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"] # #
2050 """Mapping of direction names to internal direction chars."""
2051 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2052 "west": "s", "north-west": "w", "north-east": "e"}
2054 """File IO database."""
2056 "path_save": "save",
2057 "path_record": "record_save",
2058 "path_worldconf": "confserver/world",
2059 "path_server": "server/",
2060 "path_in": "server/in",
2061 "path_out": "server/out",
2062 "path_worldstate": "server/worldstate",
2063 "tmp_suffix": "_tmp",
2064 "kicked_by_rival": False,
2065 "worldstate_updateable": False
2070 libpr = prep_library()
2071 rand = RandomnessIO()
2072 opts = parse_command_line_arguments()
2074 io_db["path_save"] = opts.savefile
2075 io_db["path_record"] = "record_" + opts.savefile
2078 io_db["verbose"] = True
2079 if None != opts.replay:
2083 except SystemExit as exit:
2084 print("ABORTING: " + exit.args[0])
2086 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")