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 != "MAP" and key != "WORLD_ACTIVE"):
216 string = string + key + " " + str(world_db[key]) + "\n"
217 string = string + mapsetter("MAP")()
218 string = string + helper("ThingActions", "TA_ID")
219 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
220 for id in world_db["ThingTypes"]:
221 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
222 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
223 string = string + helper("Things", "T_ID",
224 {"T_CARRIES": False, "carried": False,
225 "T_MEMMAP": mapsetter("T_MEMMAP"),
226 "T_MEMTHING": memthing, "fovmap": False,
227 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
228 for id in world_db["Things"]:
229 if [] != world_db["Things"][id]["T_CARRIES"]:
230 string = string + "T_ID " + str(id) + "\n"
231 for carried_id in world_db["Things"][id]["T_CARRIES"]:
232 string = string + "T_CARRIES " + str(carried_id) + "\n"
233 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
234 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
235 atomic_write(io_db["path_save"], string)
238 def obey_lines_in_file(path, name, do_record=False):
239 """Call obey() on each line of path's file, use name in input prefix."""
240 file = open(path, "r")
242 for line in file.readlines():
243 obey(line.rstrip(), name + "file line " + str(line_n),
249 def parse_command_line_arguments():
250 """Return settings values read from command line arguments."""
251 parser = argparse.ArgumentParser()
252 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
254 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
256 parser.add_argument('-v', dest='verbose', action='store_true')
257 opts, unknown = parser.parse_known_args()
262 """Ensure valid server out file belonging to current process.
264 This is done by comparing io_db["teststring"] to what's found at the start
265 of the current file at io_db["path_out"]. On failure, set
266 io_db["kicked_by_rival"] and raise SystemExit.
268 if not os.access(io_db["path_out"], os.F_OK):
269 raise SystemExit("Server output file has disappeared.")
270 file = open(io_db["path_out"], "r")
271 test = file.readline().rstrip("\n")
273 if test != io_db["teststring"]:
274 io_db["kicked_by_rival"] = True
275 msg = "Server test string in server output file does not match. This" \
276 " indicates that the current server process has been " \
277 "superseded by another one."
278 raise SystemExit(msg)
282 """Return next newline-delimited command from server in file.
284 Keep building return string until a newline is encountered. Pause between
285 unsuccessful reads, and after too much waiting, run server_test().
287 wait_on_fail = 0.03333
292 add = io_db["file_in"].readline()
294 command = command + add
295 if len(command) > 0 and "\n" == command[-1]:
296 command = command[:-1]
299 time.sleep(wait_on_fail)
300 if now + max_wait < time.time():
306 def try_worldstate_update():
307 """Write worldstate file if io_db["worldstate_updateable"] is set."""
308 if io_db["worldstate_updateable"]:
310 def draw_visible_Things(map, run):
311 for id in world_db["Things"]:
312 type = world_db["Things"][id]["T_TYPE"]
313 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
314 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
315 if (0 == run and not consumable and not alive) \
316 or (1 == run and consumable and not alive) \
317 or (2 == run and alive):
318 y = world_db["Things"][id]["T_POSY"]
319 x = world_db["Things"][id]["T_POSX"]
320 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
321 if 'v' == chr(fovflag):
322 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
323 map[(y * length) + x] = ord(c)
325 def write_map(string, map):
326 for i in range(length):
327 line = map[i * length:(i * length) + length].decode()
328 string = string + line + "\n"
332 if [] == world_db["Things"][0]["T_CARRIES"]:
333 inventory = "(none)\n"
335 for id in world_db["Things"][0]["T_CARRIES"]:
336 type_id = world_db["Things"][id]["T_TYPE"]
337 name = world_db["ThingTypes"][type_id]["TT_NAME"]
338 inventory = inventory + name + "\n"
339 # 7DRL additions: GOD_MOOD, GOD_FAVOR
340 string = str(world_db["TURN"]) + "\n" + \
341 str(world_db["GOD_MOOD"]) + "\n" + \
342 str(world_db["GOD_FAVOR"]) + "\n" + \
343 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
344 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
345 inventory + "%\n" + \
346 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
347 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
348 str(world_db["MAP_LENGTH"]) + "\n"
349 length = world_db["MAP_LENGTH"]
350 fov = bytearray(b' ' * (length ** 2))
351 for pos in range(length ** 2):
352 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
353 fov[pos] = world_db["MAP"][pos]
355 draw_visible_Things(fov, i)
356 string = write_map(string, fov)
357 mem = world_db["Things"][0]["T_MEMMAP"][:]
359 for mt in world_db["Things"][0]["T_MEMTHING"]:
360 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
361 if (i == 0 and not consumable) or (i == 1 and consumable):
362 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
363 mem[(mt[1] * length) + mt[2]] = ord(c)
364 string = write_map(string, mem)
365 atomic_write(io_db["path_worldstate"], string, delete=False)
366 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
367 io_db["worldstate_updateable"] = False
371 """Replay game from record file.
373 Use opts.replay as breakpoint turn to which to replay automatically before
374 switching to manual input by non-meta commands in server input file
375 triggering further reads of record file. Ensure opts.replay is at least 1.
376 Run try_worldstate_update() before each interactive obey()/read_command().
380 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
381 " (if so late a turn is to be found).")
382 if not os.access(io_db["path_record"], os.F_OK):
383 raise SystemExit("No record file found to replay.")
384 io_db["file_record"] = open(io_db["path_record"], "r")
385 io_db["file_record"].prefix = "record file line "
386 io_db["file_record"].line_n = 1
387 while world_db["TURN"] < opts.replay:
388 line = io_db["file_record"].readline()
391 obey(line.rstrip(), io_db["file_record"].prefix
392 + str(io_db["file_record"].line_n))
393 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
395 try_worldstate_update()
396 obey(read_command(), "in file", replay=True)
400 """Play game by server input file commands. Before, load save file found.
402 If no save file is found, a new world is generated from the commands in the
403 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
404 command and all that follow via the server input file. Run
405 try_worldstate_update() before each interactive obey()/read_command().
407 if os.access(io_db["path_save"], os.F_OK):
408 obey_lines_in_file(io_db["path_save"], "save")
410 if not os.access(io_db["path_worldconf"], os.F_OK):
411 msg = "No world config file from which to start a new world."
412 raise SystemExit(msg)
413 obey_lines_in_file(io_db["path_worldconf"], "world config ",
415 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
417 try_worldstate_update()
418 obey(read_command(), "in file", do_record=True)
422 """(Re-)make island map.
424 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
425 start with one land cell in the middle, then go into cycle of repeatedly
426 selecting a random sea cell and transforming it into land if it is neighbor
427 to land. The cycle ends when a land cell is due to be created at the map's
428 border. Then put some trees on the map (TODO: more precise algorithm desc).
430 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
432 def is_neighbor(coordinates, type):
435 length = world_db["MAP_LENGTH"]
437 diag_west = x + (ind > 0)
438 diag_east = x + (ind < (length - 1))
439 pos = (y * length) + x
440 if (y > 0 and diag_east
441 and type == chr(world_db["MAP"][pos - length + ind])) \
443 and type == chr(world_db["MAP"][pos + 1])) \
444 or (y < (length - 1) and diag_east
445 and type == chr(world_db["MAP"][pos + length + ind])) \
446 or (y > 0 and diag_west
447 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
449 and type == chr(world_db["MAP"][pos - 1])) \
450 or (y < (length - 1) and diag_west
451 and type == chr(world_db["MAP"][pos + length - (not ind)])):
455 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
456 length = world_db["MAP_LENGTH"]
457 add_half_width = (not (length % 2)) * int(length / 2)
458 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
460 y = rand.next() % length
461 x = rand.next() % length
462 pos = (y * length) + x
463 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
464 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
466 world_db["MAP"][pos] = ord(".")
467 n_trees = int((length ** 2) / 16)
469 while (i_trees <= n_trees):
470 single_allowed = rand.next() % 32
471 y = rand.next() % length
472 x = rand.next() % length
473 pos = (y * length) + x
474 if "." == chr(world_db["MAP"][pos]) \
475 and ((not single_allowed) or is_neighbor((y, x), "X")):
476 world_db["MAP"][pos] = ord("X")
478 # This all-too-precise replica of the original C code misses iter_limit().
479 n_colons = int((length ** 2) / 16) # #
481 while (i_colons <= n_colons): # #
482 single_allowed = rand.next() % 256 # #
483 y = rand.next() % length # #
484 x = rand.next() % length # #
485 pos = (y * length) + x # #
486 if ("." == chr(world_db["MAP"][pos]) # #
487 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
488 world_db["MAP"][pos] = ord(":") # #
490 altar_placed = False # #
491 while not altar_placed: # #
492 y = rand.next() % length # #
493 x = rand.next() % length # #
494 pos = (y * length) + x # #
495 if (("." == chr(world_db["MAP"][pos] # #
496 or ":" == chr(world_db["MAP"][pos]))
497 and not is_neighbor((y, x), 'X'))): # #
498 world_db["MAP"][pos] = ord("_") # #
499 world_db["altar"] = (y, x) # #
500 altar_placed = True # #
503 def update_map_memory(t, age_map=True):
504 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
506 def age_some_memdepthmap_on_nonfov_cells():
507 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
511 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
512 # if not ord_v == t["fovmap"][pos]
513 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
514 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
515 # if not rand.next() % (2 **
516 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
517 # t["T_MEMDEPTHMAP"][pos] += 1
518 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
519 fovmap = c_pointer_to_bytearray(t["fovmap"])
520 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
522 if not t["T_MEMMAP"]:
523 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
524 if not t["T_MEMDEPTHMAP"]:
525 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
529 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
530 if ord_v == t["fovmap"][pos]]:
531 t["T_MEMDEPTHMAP"][pos] = ord_0
532 if ord_space == t["T_MEMMAP"][pos]:
533 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
535 age_some_memdepthmap_on_nonfov_cells()
536 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
537 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
539 for id in [id for id in world_db["Things"]
540 if not world_db["Things"][id]["carried"]]:
541 type = world_db["Things"][id]["T_TYPE"]
542 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
543 y = world_db["Things"][id]["T_POSY"]
544 x = world_db["Things"][id]["T_POSX"]
545 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
546 t["T_MEMTHING"].append((type, y, x))
549 def set_world_inactive():
550 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
552 if os.access(io_db["path_worldstate"], os.F_OK):
553 os.remove(io_db["path_worldstate"])
554 world_db["WORLD_ACTIVE"] = 0
557 def integer_test(val_string, min, max=None):
558 """Return val_string if possible integer >= min and <= max, else None."""
560 val = int(val_string)
561 if val < min or (max is not None and val > max):
565 msg = "Ignoring: Please use integer >= " + str(min)
567 msg += " and <= " + str(max)
573 def setter(category, key, min, max=None):
574 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
577 val = integer_test(val_string, min, max)
581 if category == "Thing":
582 id_store = command_tid
583 decorator = test_Thing_id
584 elif category == "ThingType":
585 id_store = command_ttid
586 decorator = test_ThingType_id
587 elif category == "ThingAction":
588 id_store = command_taid
589 decorator = test_ThingAction_id
593 val = integer_test(val_string, min, max)
595 world_db[category + "s"][id_store.id][key] = val
599 def build_fov_map(t):
600 """Build Thing's FOV map."""
601 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
602 fovmap = c_pointer_to_bytearray(t["fovmap"])
603 map = c_pointer_to_bytearray(world_db["MAP"])
604 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
605 raise RuntimeError("Malloc error in build_fov_Map().")
609 """Send quick usage info to log."""
610 strong_write(io_db["file_out"], "LOG "
611 + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n")
612 strong_write(io_db["file_out"], "LOG "
613 + "Use 'p' to pick up objects, and 'D' to drop them.\n")
614 strong_write(io_db["file_out"], "LOG "
615 + "Some objects can be used (such as: eaten) by 'u' if "
616 + "they are in your inventory. "
617 + "Use 'UP'/'DOWN' to navigate the inventory.\n")
618 strong_write(io_db["file_out"], "LOG "
619 + "Use 'l' to toggle 'look' mode (move an exploration cursor "
620 + "instead of the player over the map).\n")
621 strong_write(io_db["file_out"], "LOG See README file for more details.\n")
622 strong_write(io_db["file_out"], "LOG \n")
625 def decrement_lifepoints(t):
626 """Decrement t's lifepoints by 1, and if to zero, corpse it.
628 If t is the player avatar, only blank its fovmap, so that the client may
629 still display memory data. On non-player things, erase fovmap and memory.
630 Dying actors drop all their things.
632 # 7DRL: Also decrements God's mood; deaths heavily so.
633 # 7DRL: Return 1 if death, else 0.
634 t["T_LIFEPOINTS"] -= 1
635 world_db["GOD_MOOD"] -= 1 # #
636 if 0 == t["T_LIFEPOINTS"]:
637 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
638 world_db["GOD_MOOD"] -= sadness # #
639 for id in t["T_CARRIES"]:
640 t["T_CARRIES"].remove(id)
641 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
642 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
643 world_db["Things"][id]["carried"] = False
644 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
645 if world_db["Things"][0] == t:
646 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
647 strong_write(io_db["file_out"], "LOG You die.\n")
650 t["T_MEMMAP"] = False
651 t["T_MEMDEPTHMAP"] = False
657 def add_gods_favor(i): # #
658 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
659 def favor_multiplier(i):
661 threshold = math.e * x
662 mood = world_db["GOD_MOOD"]
665 i = i * math.log(mood / x)
666 elif -mood > threshold:
667 i = i / math.log(-mood / x)
669 if -mood > threshold:
670 i = i * math.log(-mood / x)
672 i = i / math.log(mood / x)
674 world_db["GOD_FAVOR"] += favor_multiplier(i)
677 def mv_yx_in_dir_legal(dir, y, x):
678 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
679 dir_c = dir.encode("ascii")[0]
680 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
682 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
683 return (test, libpr.result_y(), libpr.result_x())
686 def enter_altar(): # #
687 """What happens when the player enters the altar."""
688 if world_db["GAME_WON"]:
689 strong_write(io_db["file_out"],
690 "LOG You step on a soul-less slab of stone.\n")
692 strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
693 if world_db["GOD_FAVOR"] > 9000:
694 world_db["GAME_WON"] = 1
695 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
696 + "\"You have proven yourself worthy of my respect. "
697 + "You were a good citizen to the island, and sometimes "
698 + "a better steward to its inhabitants than me. The "
699 + "island shall miss you when you leave. But you have "
700 + "earned the right to do so. Take this "
701 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
702 + " and USE it when you please. It will take you to "
703 + "where you came from. (But do feel free to stay here "
704 + "as long as you like.)\"\n")
705 id = id_setter(-1, "Things")
706 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
711 """Make t do nothing (but loudly, if player avatar)."""
712 if t == world_db["Things"][0]:
713 strong_write(io_db["file_out"], "LOG You wait.\n")
717 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
718 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
719 # 7DRL: Player entering the altar triggers enter_altar().
721 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
722 t["T_POSY"], t["T_POSX"])
723 if 1 == move_result[0]:
724 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
725 passable = ("." == chr(world_db["MAP"][pos]) or
726 ":" == chr(world_db["MAP"][pos]) or # #
727 "_" == chr(world_db["MAP"][pos])) # #
728 hitted = [id for id in world_db["Things"]
729 if world_db["Things"][id] != t
730 if world_db["Things"][id]["T_LIFEPOINTS"]
731 if world_db["Things"][id]["T_POSY"] == move_result[1]
732 if world_db["Things"][id]["T_POSX"] == move_result[2]]
735 if t == world_db["Things"][0]:
736 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
737 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
738 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
740 add_gods_favor(-1) # #
742 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
743 strong_write(io_db["file_out"], "LOG " + hitter_name +
745 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
746 if test and t == world_db["Things"][0]: # #
747 add_gods_favor(-test) # #
749 dir = [dir for dir in directions_db
750 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
752 t["T_POSY"] = move_result[1]
753 t["T_POSX"] = move_result[2]
754 for id in t["T_CARRIES"]:
755 world_db["Things"][id]["T_POSY"] = move_result[1]
756 world_db["Things"][id]["T_POSX"] = move_result[2]
758 if t == world_db["Things"][0]:
759 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
760 if (move_result[1] == world_db["altar"][0] and # #
761 move_result[2] == world_db["altar"][1]): # #
763 elif t == world_db["Things"][0]:
764 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
767 def actor_pick_up(t):
768 """Make t pick up (topmost?) Thing from ground into inventory."""
769 # Topmostness is actually not defined so far. Picks most nutritious Thing.
770 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
771 used_slots = len(t["T_CARRIES"]) # #
772 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
773 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
774 if not world_db["Things"][id]["carried"]
775 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
776 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
781 type = world_db["Things"][id]["T_TYPE"]
782 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
783 nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
785 world_db["Things"][highest_id]["carried"] = True
786 if (t != world_db["Things"][0] and # #
787 world_db["Things"][highest_id]["T_PLAYERDROP"]): # #
788 x = world_db["Things"][highest_id]["T_TYPE"]
789 score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32 # #
790 add_gods_favor(score) # #
791 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0 # #
792 t["T_CARRIES"].append(highest_id)
793 if t == world_db["Things"][0]:
794 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
795 elif t == world_db["Things"][0]:
796 err = "You try to pick up an object, but there is none."
797 strong_write(io_db["file_out"], "LOG " + err + "\n")
798 elif t == world_db["Things"][0]: # #
799 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
800 "No storage room to carry more.\n") # #
804 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
805 # TODO: Handle case where T_ARGUMENT matches nothing.
806 if len(t["T_CARRIES"]):
807 id = t["T_CARRIES"][t["T_ARGUMENT"]]
808 t["T_CARRIES"].remove(id)
809 world_db["Things"][id]["carried"] = False
810 if t == world_db["Things"][0]:
811 strong_write(io_db["file_out"], "LOG You drop an object.\n")
812 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
813 elif t == world_db["Things"][0]:
814 err = "You try to drop an object, but you own none."
815 strong_write(io_db["file_out"], "LOG " + err + "\n")
819 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
820 # TODO: Handle case where T_ARGUMENT matches nothing.
821 # 7DLR: Handle SLIPPERS-type Thing use.
822 if len(t["T_CARRIES"]):
823 id = t["T_CARRIES"][t["T_ARGUMENT"]]
824 type = world_db["Things"][id]["T_TYPE"]
825 if type == world_db["SLIPPERS"]: # #
826 if t == world_db["Things"][0]: # #
827 strong_write(io_db["file_out"], "LOG You use the " # #
828 + world_db["ThingTypes"][type]["TT_NAME"] # #
829 + ". It glows in wondrous colors, and emits " # #
830 + "a sound as if from a dying cat. The " # #
831 + "Island God laughs.\n") # #
832 t["T_LIFEPOINTS"] = 1 # #
833 decrement_lifepoints(t) # #
834 elif world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
835 t["T_CARRIES"].remove(id)
836 del world_db["Things"][id]
837 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
838 if t == world_db["Things"][0]:
839 strong_write(io_db["file_out"],
840 "LOG You consume this object.\n")
841 elif t == world_db["Things"][0]:
842 strong_write(io_db["file_out"],
843 "LOG You try to use this object, but fail.\n")
844 elif t == world_db["Things"][0]:
845 strong_write(io_db["file_out"],
846 "LOG You try to use an object, but you own none.\n")
849 def thingproliferation(t, prol_map):
850 """To chance of 1/TT_PROLIFERATE,create t offspring in open neighbor cell.
852 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
853 marked "." in prol_map. If there are several map cell candidates, one is
856 # 7DRL: success increments God's mood
857 # 7DRL: Things proliferate only on ":" ground.
858 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
859 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
861 for dir in [directions_db[key] for key in directions_db]:
862 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
863 if mv_result[0] and ord(":") == prol_map[mv_result[1] # #
864 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
865 * world_db["MAP_LENGTH"]
867 candidates.append((mv_result[1], mv_result[2]))
869 i = rand.next() % len(candidates)
870 id = id_setter(-1, "Things")
871 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
872 world_db["Things"][id] = newT
873 world_db["GOD_MOOD"] += 1 # #
877 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
879 On success, decrease satiation score by 32.
881 # 7DRL: Successful heals increment God's mood.
882 if t["T_SATIATION"] > 0 \
883 and t["T_LIFEPOINTS"] < \
884 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
885 and 0 == (rand.next() % 31) \
886 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
887 if world_db["ThingActions"][id]["TA_NAME"] ==
889 t["T_LIFEPOINTS"] += 1
890 world_db["GOD_MOOD"] += 1 # #
891 t["T_SATIATION"] -= 32
892 if t == world_db["Things"][0]:
893 strong_write(io_db["file_out"], "LOG You heal.\n")
897 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
898 if t["T_SATIATION"] > -32768:
899 t["T_SATIATION"] -= 1
900 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
901 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
902 raise RuntimeError("A thing that should not hunger is hungering.")
903 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
904 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
905 if t == world_db["Things"][0]:
906 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
907 decrement_lifepoints(t)
910 def get_dir_to_target(t, filter):
911 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
913 The path-wise nearest target is chosen, via the shortest available path.
914 Target must not be t. On succcess, return positive value, else False.
916 "a": Thing in FOV is below a certain distance, animate, but of ThingType
917 that is not t's, and starts out weaker than t is; build path as
918 avoiding things of t's ThingType
919 "f": neighbor cell (not inhabited by any animate Thing) further away from
920 animate Thing not further than x steps away and in FOV and of a
921 ThingType that is not t's, and starts out stronger or as strong as t
922 is currently; or (cornered), if no such flight cell, but Thing of
923 above criteria is too near,1 a cell closer to it, or, if less near,
925 "c": Thing in memorized map is consumable
926 "s": memory map cell with greatest-reachable degree of unexploredness
929 def zero_score_map_where_char_on_memdepthmap(c):
930 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
931 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
932 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
933 # set_map_score(i, 0)
934 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
935 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
936 raise RuntimeError("No score map allocated for "
937 "zero_score_map_where_char_on_memdepthmap().")
939 def set_map_score(pos, score):
940 test = libpr.set_map_score(pos, score)
942 raise RuntimeError("No score map allocated for set_map_score().")
944 def get_map_score(pos):
945 result = libpr.get_map_score(pos)
947 raise RuntimeError("No score map allocated for get_map_score().")
951 if t["fovmap"] and ("a" == filter or "f" == filter):
952 for id in world_db["Things"]:
953 Thing = world_db["Things"][id]
954 if Thing != t and Thing["T_LIFEPOINTS"] and \
955 t["T_TYPE"] != Thing["T_TYPE"] and \
956 'v' == chr(t["fovmap"][(Thing["T_POSY"]
957 * world_db["MAP_LENGTH"])
959 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
960 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
962 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
965 elif t["T_MEMMAP"] and "c" == filter:
966 for mt in t["T_MEMTHING"]:
967 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
969 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
973 def set_cells_passable_on_memmap_to_65534_on_scoremap():
974 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
976 # memmap = t["T_MEMMAP"]
977 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
978 # if ord_dot == memmap[i]]:
979 # set_map_score(i, 65534) # i.e. 65535-1
980 map = c_pointer_to_bytearray(t["T_MEMMAP"])
981 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
982 raise RuntimeError("No score map allocated for "
983 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
985 def init_score_map():
986 test = libpr.init_score_map()
988 raise RuntimeError("Malloc error in init_score_map().")
991 set_cells_passable_on_memmap_to_65534_on_scoremap()
993 for id in world_db["Things"]:
994 Thing = world_db["Things"][id]
995 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
997 if t != Thing and Thing["T_LIFEPOINTS"] and \
998 t["T_TYPE"] != Thing["T_TYPE"] and \
999 ord_v == t["fovmap"][pos] and \
1000 t["T_LIFEPOINTS"] > \
1001 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1002 set_map_score(pos, 0)
1003 elif t["T_TYPE"] == Thing["T_TYPE"]:
1004 set_map_score(pos, 65535)
1006 for id in [id for id in world_db["Things"]
1007 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1008 Thing = world_db["Things"][id]
1009 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1011 if t["T_TYPE"] != Thing["T_TYPE"] and \
1012 ord_v == t["fovmap"][pos] and \
1013 t["T_LIFEPOINTS"] <= \
1014 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1015 set_map_score(pos, 0)
1017 for mt in [mt for mt in t["T_MEMTHING"]
1018 if ord_blank != t["T_MEMMAP"][mt[1]
1019 * world_db["MAP_LENGTH"]
1021 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
1022 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1024 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1026 def rand_target_dir(neighbors, cmp, dirs):
1029 for i in range(len(dirs)):
1030 if cmp == neighbors[i]:
1031 candidates.append(dirs[i])
1033 return candidates[rand.next() % n_candidates] if n_candidates else 0
1035 def get_neighbor_scores(dirs, eye_pos):
1037 if libpr.ready_neighbor_scores(eye_pos):
1038 raise RuntimeError("No score map allocated for " +
1039 "ready_neighbor_scores.()")
1040 for i in range(len(dirs)):
1041 scores.append(libpr.get_neighbor_score(i))
1044 def get_dir_from_neighbors():
1045 dir_to_target = False
1047 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1048 neighbors = get_neighbor_scores(dirs, eye_pos)
1050 inhabited = [world_db["Things"][id]["T_POSY"]
1051 * world_db["MAP_LENGTH"]
1052 + world_db["Things"][id]["T_POSX"]
1053 for id in world_db["Things"]
1054 if world_db["Things"][id]["T_LIFEPOINTS"]]
1055 for i in range(len(dirs)):
1056 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1057 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1059 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1060 neighbors[i] = 65535
1062 minmax_start = 0 if "f" == filter else 65535 - 1
1063 minmax_neighbor = minmax_start
1064 for i in range(len(dirs)):
1065 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1066 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1067 or ("f" != filter and minmax_neighbor > neighbors[i]):
1068 minmax_neighbor = neighbors[i]
1069 if minmax_neighbor != minmax_start:
1070 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1072 if not dir_to_target:
1073 if 1 == get_map_score(eye_pos):
1074 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1075 elif 3 >= get_map_score(eye_pos):
1076 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1078 world_db["ThingActions"][id]["TA_NAME"]
1081 elif dir_to_target and 3 < get_map_score(eye_pos):
1083 elif "a" == filter and 10 <= get_map_score(eye_pos):
1085 return dir_to_target
1087 dir_to_target = False
1089 run_i = 9 + 1 if "s" == filter else 1
1090 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1093 mem_depth_c = b'9' if b' ' == mem_depth_c \
1094 else bytes([mem_depth_c[0] - 1])
1095 if libpr.dijkstra_map():
1096 raise RuntimeError("No score map allocated for dijkstra_map().")
1097 dir_to_target = get_dir_from_neighbors()
1098 libpr.free_score_map()
1099 if dir_to_target and str == type(dir_to_target):
1100 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1101 if world_db["ThingActions"][id]["TA_NAME"]
1103 t["T_ARGUMENT"] = ord(dir_to_target)
1104 return dir_to_target
1107 def standing_on_consumable(t):
1108 """Return True/False whether t is standing on a consumable."""
1109 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1110 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1111 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1112 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1118 def get_inventory_slot_to_consume(t):
1119 """Return slot Id of strongest consumable in t's inventory, else -1."""
1120 cmp_consumability = 0
1123 for id in t["T_CARRIES"]:
1124 type = world_db["Things"][id]["T_TYPE"]
1125 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
1126 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1133 """Determine next command/argment for actor t via AI algorithms.
1135 AI will look for, and move towards, enemies (animate Things not of their
1136 own ThingType); if they see none, they will consume consumables in their
1137 inventory; if there are none, they will pick up what they stand on if they
1138 stand on consumables; if they stand on none, they will move towards the
1139 next consumable they see or remember on the map; if they see or remember
1140 none, they will explore parts of the map unseen since ever or for at least
1141 one turn; if there is nothing to explore, they will simply wait.
1143 # 7DRL add: Don't pick up or search things when inventory is full.
1144 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1145 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1146 if not get_dir_to_target(t, "f"):
1147 sel = get_inventory_slot_to_consume(t)
1149 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1150 if world_db["ThingActions"][id]["TA_NAME"]
1152 t["T_ARGUMENT"] = sel
1153 elif standing_on_consumable(t) \
1154 and (len(t["T_CARRIES"]) < # #
1155 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1156 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1157 if world_db["ThingActions"][id]["TA_NAME"]
1160 (len(t["T_CARRIES"]) < # #
1161 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1162 and get_dir_to_target(t, "c"))) and \
1163 (not get_dir_to_target(t, "a")):
1164 get_dir_to_target(t, "s")
1168 """Run game world and its inhabitants until new player input expected."""
1170 whilebreaker = False
1171 while world_db["Things"][0]["T_LIFEPOINTS"]:
1172 proliferable_map = world_db["MAP"][:]
1173 for id in [id for id in world_db["Things"]
1174 if not world_db["Things"][id]["carried"]]:
1175 y = world_db["Things"][id]["T_POSY"]
1176 x = world_db["Things"][id]["T_POSX"]
1177 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1178 for id in [id for id in world_db["Things"]]: # Only what's from start!
1179 if not id in world_db["Things"] or \
1180 world_db["Things"][id]["carried"]: # May have been consumed or
1181 continue # picked up during turn …
1182 Thing = world_db["Things"][id]
1183 if Thing["T_LIFEPOINTS"]:
1184 if not Thing["T_COMMAND"]:
1185 update_map_memory(Thing)
1192 if Thing["T_LIFEPOINTS"]:
1193 Thing["T_PROGRESS"] += 1
1194 taid = [a for a in world_db["ThingActions"]
1195 if a == Thing["T_COMMAND"]][0]
1196 ThingAction = world_db["ThingActions"][taid]
1197 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1198 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1199 Thing["T_COMMAND"] = 0
1200 Thing["T_PROGRESS"] = 0
1201 thingproliferation(Thing, proliferable_map)
1204 world_db["TURN"] += 1
1207 def new_Thing(type, pos=(0, 0)):
1208 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1210 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1215 "T_PLAYERDROP": 0, # #
1223 "T_MEMDEPTHMAP": False,
1226 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1227 build_fov_map(thing)
1231 def id_setter(id, category, id_store=False, start_at_1=False):
1232 """Set ID of object of category to manipulate ID unused? Create new one.
1234 The ID is stored as id_store.id (if id_store is set). If the integer of the
1235 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1236 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1237 always returned when no new object is created, otherwise the new object's
1240 min = 0 if start_at_1 else -1
1242 id = integer_test(id, min)
1244 if id in world_db[category]:
1249 if (start_at_1 and 0 == id) \
1250 or ((not start_at_1) and (id < 0)):
1251 id = 0 if start_at_1 else -1
1254 if id not in world_db[category]:
1262 """Send PONG line to server output file."""
1263 strong_write(io_db["file_out"], "PONG\n")
1267 """Abort server process."""
1268 if None == opts.replay:
1269 if world_db["WORLD_ACTIVE"]:
1271 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1272 raise SystemExit("received QUIT command")
1275 def command_thingshere(str_y, str_x):
1276 """Write to out file list of Things known to player at coordinate y, x."""
1277 if world_db["WORLD_ACTIVE"]:
1278 y = integer_test(str_y, 0, 255)
1279 x = integer_test(str_x, 0, 255)
1280 length = world_db["MAP_LENGTH"]
1281 if None != y and None != x and y < length and x < length:
1282 pos = (y * world_db["MAP_LENGTH"]) + x
1283 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1284 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1285 for id in world_db["Things"]:
1286 if y == world_db["Things"][id]["T_POSY"] \
1287 and x == world_db["Things"][id]["T_POSX"] \
1288 and not world_db["Things"][id]["carried"]:
1289 type = world_db["Things"][id]["T_TYPE"]
1290 name = world_db["ThingTypes"][type]["TT_NAME"]
1291 strong_write(io_db["file_out"], name + "\n")
1293 for mt in world_db["Things"][0]["T_MEMTHING"]:
1294 if y == mt[1] and x == mt[2]:
1295 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1296 strong_write(io_db["file_out"], name + "\n")
1297 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1299 print("Ignoring: Invalid map coordinates.")
1301 print("Ignoring: Command only works on existing worlds.")
1304 def play_commander(action, args=False):
1305 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1307 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1311 id = [x for x in world_db["ThingActions"]
1312 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1313 world_db["Things"][0]["T_COMMAND"] = id
1316 def set_command_and_argument_int(str_arg):
1317 val = integer_test(str_arg, 0, 255)
1319 world_db["Things"][0]["T_ARGUMENT"] = val
1322 def set_command_and_argument_movestring(str_arg):
1323 if str_arg in directions_db:
1324 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1327 print("Ignoring: Argument must be valid direction string.")
1329 if action == "move":
1330 return set_command_and_argument_movestring
1332 return set_command_and_argument_int
1337 def command_seedrandomness(seed_string):
1338 """Set rand seed to int(seed_string)."""
1339 val = integer_test(seed_string, 0, 4294967295)
1344 def command_makeworld(seed_string):
1345 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1347 Seed rand with seed. Do more only with a "wait" ThingAction and
1348 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1349 world_db["Things"] emptied, call make_map() and set
1350 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1351 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1352 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1353 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1357 # def free_pos(plant=False):
1358 def free_pos(plant=False): # #
1361 err = "Space to put thing on too hard to find. Map too small?"
1363 y = rand.next() % world_db["MAP_LENGTH"]
1364 x = rand.next() % world_db["MAP_LENGTH"]
1365 pos = y * world_db["MAP_LENGTH"] + x;
1367 and "." == chr(world_db["MAP"][pos])) \
1368 or ":" == chr(world_db["MAP"][pos]): # #
1372 raise SystemExit(err)
1373 # Replica of C code, wrongly ignores animatedness of new Thing.
1374 pos_clear = (0 == len([id for id in world_db["Things"]
1375 if world_db["Things"][id]["T_LIFEPOINTS"]
1376 if world_db["Things"][id]["T_POSY"] == y
1377 if world_db["Things"][id]["T_POSX"] == x]))
1382 val = integer_test(seed_string, 0, 4294967295)
1386 player_will_be_generated = False
1387 playertype = world_db["PLAYER_TYPE"]
1388 for ThingType in world_db["ThingTypes"]:
1389 if playertype == ThingType:
1390 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1391 player_will_be_generated = True
1393 if not player_will_be_generated:
1394 print("Ignoring: No player type with start number >0 defined.")
1397 for ThingAction in world_db["ThingActions"]:
1398 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1401 print("Ignoring: No thing action with name 'wait' defined.")
1403 if not world_db["SLIPPERS"] in world_db["ThingTypes"]: # #
1404 print("Ignoring: No valid SLIPPERS set.") # #
1406 world_db["Things"] = {}
1408 world_db["WORLD_ACTIVE"] = 1
1409 world_db["TURN"] = 1
1410 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1411 id = id_setter(-1, "Things")
1412 world_db["Things"][id] = new_Thing(playertype, free_pos())
1413 if not world_db["Things"][0]["fovmap"]:
1414 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1415 world_db["Things"][0]["fovmap"] = empty_fovmap
1416 update_map_memory(world_db["Things"][0])
1417 for type in world_db["ThingTypes"]:
1418 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1419 if type != playertype:
1420 id = id_setter(-1, "Things")
1421 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1422 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1423 strong_write(io_db["file_out"], "NEW_WORLD\n")
1427 def command_maplength(maplength_string):
1428 """Redefine map length. Invalidate map, therefore lose all things on it."""
1429 val = integer_test(maplength_string, 1, 256)
1431 world_db["MAP_LENGTH"] = val
1432 world_db["MAP"] = False
1433 set_world_inactive()
1434 world_db["Things"] = {}
1435 libpr.set_maplength(val)
1438 def command_worldactive(worldactive_string):
1439 """Toggle world_db["WORLD_ACTIVE"] if possible.
1441 An active world can always be set inactive. An inactive world can only be
1442 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1443 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1444 Also call log_help().
1446 # 7DRL: altar must be on map, and (valid) SLIPPERS must be set for world
1448 val = integer_test(worldactive_string, 0, 1)
1450 if 0 != world_db["WORLD_ACTIVE"]:
1452 set_world_inactive()
1454 print("World already active.")
1455 elif 0 == world_db["WORLD_ACTIVE"]:
1457 for ThingAction in world_db["ThingActions"]:
1458 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1461 player_exists = False
1462 for Thing in world_db["Things"]:
1464 player_exists = True
1466 valid_slippers = world_db["SLIPPERS"] in world_db["ThingTypes"] # #
1467 altar_found = False # #
1468 if world_db["MAP"]: # #
1469 pos = world_db["MAP"].find(b'_') # #
1471 y = int(pos / world_db["MAP_LENGTH"]) # #
1472 x = pos % world_db["MAP_LENGTH"] # #
1473 world_db["altar"] = (y, x) # #
1474 altar_found = True # #
1475 if wait_exists and player_exists and world_db["MAP"] \
1476 and altar_found and valid_slippers: # #
1477 for id in world_db["Things"]:
1478 if world_db["Things"][id]["T_LIFEPOINTS"]:
1479 build_fov_map(world_db["Things"][id])
1481 update_map_memory(world_db["Things"][id], False)
1482 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1483 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1484 world_db["Things"][0]["fovmap"] = empty_fovmap
1485 world_db["WORLD_ACTIVE"] = 1
1488 print("Ignoring: Not all conditions for world activation met.")
1491 def command_slippers(str_int): # #
1492 """Set SLIPPERS, but deactivate world if not in ThingTypes."""
1493 val = integer_test(str_int, 0)
1495 world_db["SLIPPERS"] = val
1496 if world_db["WORLD_ACTIVE"] and \
1497 world_db["SLIPPERS"] not in world_db["ThingTypes"]:
1498 world_db["WORLD_ACTIVE"] = 0
1499 print("SLIPPERS matches no known ThingTypes, deactivating world.")
1502 def test_for_id_maker(object, category):
1503 """Return decorator testing for object having "id" attribute."""
1506 if hasattr(object, "id"):
1509 print("Ignoring: No " + category +
1510 " defined to manipulate yet.")
1515 def command_tid(id_string):
1516 """Set ID of Thing to manipulate. ID unused? Create new one.
1518 Default new Thing's type to the first available ThingType, others: zero.
1520 id = id_setter(id_string, "Things", command_tid)
1522 if world_db["ThingTypes"] == {}:
1523 print("Ignoring: No ThingType to settle new Thing in.")
1525 type = list(world_db["ThingTypes"].keys())[0]
1526 world_db["Things"][id] = new_Thing(type)
1529 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1533 def command_tcommand(str_int):
1534 """Set T_COMMAND of selected Thing."""
1535 val = integer_test(str_int, 0)
1537 if 0 == val or val in world_db["ThingActions"]:
1538 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1540 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1544 def command_ttype(str_int):
1545 """Set T_TYPE of selected Thing."""
1546 val = integer_test(str_int, 0)
1548 if val in world_db["ThingTypes"]:
1549 world_db["Things"][command_tid.id]["T_TYPE"] = val
1551 print("Ignoring: ThingType ID belongs to no known ThingType.")
1555 def command_tcarries(str_int):
1556 """Append int(str_int) to T_CARRIES of selected Thing.
1558 The ID int(str_int) must not be of the selected Thing, and must belong to a
1559 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1561 val = integer_test(str_int, 0)
1563 if val == command_tid.id:
1564 print("Ignoring: Thing cannot carry itself.")
1565 elif val in world_db["Things"] \
1566 and not world_db["Things"][val]["carried"]:
1567 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1568 world_db["Things"][val]["carried"] = True
1570 print("Ignoring: Thing not available for carrying.")
1571 # Note that the whole carrying structure is different from the C version:
1572 # Carried-ness is marked by a "carried" flag, not by Things containing
1573 # Things internally.
1577 def command_tmemthing(str_t, str_y, str_x):
1578 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1580 The type must fit to an existing ThingType, and the position into the map.
1582 type = integer_test(str_t, 0)
1583 posy = integer_test(str_y, 0, 255)
1584 posx = integer_test(str_x, 0, 255)
1585 if None != type and None != posy and None != posx:
1586 if type not in world_db["ThingTypes"] \
1587 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1588 print("Ignoring: Illegal value for thing type or position.")
1590 memthing = (type, posy, posx)
1591 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1594 def setter_map(maptype):
1595 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1597 If no map of maptype exists yet, initialize it with ' ' bytes first.
1600 def valid_map_line(str_int, mapline):
1601 val = integer_test(str_int, 0, 255)
1603 if val >= world_db["MAP_LENGTH"]:
1604 print("Illegal value for map line number.")
1605 elif len(mapline) != world_db["MAP_LENGTH"]:
1606 print("Map line length is unequal map width.")
1611 def nonThingMap_helper(str_int, mapline):
1612 val = valid_map_line(str_int, mapline)
1614 length = world_db["MAP_LENGTH"]
1615 if not world_db["MAP"]:
1616 map = bytearray(b' ' * (length ** 2))
1618 map = world_db["MAP"]
1619 map[val * length:(val * length) + length] = mapline.encode()
1620 if not world_db["MAP"]:
1621 world_db["MAP"] = map
1624 def ThingMap_helper(str_int, mapline):
1625 val = valid_map_line(str_int, mapline)
1627 length = world_db["MAP_LENGTH"]
1628 if not world_db["Things"][command_tid.id][maptype]:
1629 map = bytearray(b' ' * (length ** 2))
1631 map = world_db["Things"][command_tid.id][maptype]
1632 map[val * length:(val * length) + length] = mapline.encode()
1633 if not world_db["Things"][command_tid.id][maptype]:
1634 world_db["Things"][command_tid.id][maptype] = map
1636 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1639 def setter_tpos(axis):
1640 """Generate setter for T_POSX or T_POSY of selected Thing.
1642 If world is active, rebuilds animate things' fovmap, player's memory map.
1645 def helper(str_int):
1646 val = integer_test(str_int, 0, 255)
1648 if val < world_db["MAP_LENGTH"]:
1649 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1650 if world_db["WORLD_ACTIVE"] \
1651 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1652 build_fov_map(world_db["Things"][command_tid.id])
1653 if 0 == command_tid.id:
1654 update_map_memory(world_db["Things"][command_tid.id])
1656 print("Ignoring: Position is outside of map.")
1660 def command_ttid(id_string):
1661 """Set ID of ThingType to manipulate. ID unused? Create new one.
1663 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1665 id = id_setter(id_string, "ThingTypes", command_ttid)
1667 world_db["ThingTypes"][id] = {
1668 "TT_NAME": "(none)",
1671 "TT_PROLIFERATE": 0,
1672 "TT_START_NUMBER": 0,
1673 "TT_STORAGE": 0, # #
1679 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1683 def command_ttname(name):
1684 """Set TT_NAME of selected ThingType."""
1685 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1689 def command_ttsymbol(char):
1690 """Set TT_SYMBOL of selected ThingType. """
1692 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1694 print("Ignoring: Argument must be single character.")
1698 def command_ttcorpseid(str_int):
1699 """Set TT_CORPSE_ID of selected ThingType."""
1700 val = integer_test(str_int, 0)
1702 if val in world_db["ThingTypes"]:
1703 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1705 print("Ignoring: Corpse ID belongs to no known ThignType.")
1708 def command_taid(id_string):
1709 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1711 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1713 id = id_setter(id_string, "ThingActions", command_taid, True)
1715 world_db["ThingActions"][id] = {
1721 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1724 @test_ThingAction_id
1725 def command_taname(name):
1726 """Set TA_NAME of selected ThingAction.
1728 The name must match a valid thing action function. If after the name
1729 setting no ThingAction with name "wait" remains, call set_world_inactive().
1731 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1732 or name == "pick_up":
1733 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1734 if 1 == world_db["WORLD_ACTIVE"]:
1735 wait_defined = False
1736 for id in world_db["ThingActions"]:
1737 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1740 if not wait_defined:
1741 set_world_inactive()
1743 print("Ignoring: Invalid action name.")
1744 # In contrast to the original,naming won't map a function to a ThingAction.
1748 """Call ai() on player Thing, then turn_over()."""
1749 ai(world_db["Things"][0])
1753 """Commands database.
1755 Map command start tokens to ([0]) number of expected command arguments, ([1])
1756 the command's meta-ness (i.e. is it to be written to the record file, is it to
1757 be ignored in replay mode if read from server input file), and ([2]) a function
1761 "QUIT": (0, True, command_quit),
1762 "PING": (0, True, command_ping),
1763 "THINGS_HERE": (2, True, command_thingshere),
1764 "MAKE_WORLD": (1, False, command_makeworld),
1765 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1766 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1767 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1768 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1769 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1770 "MAP_LENGTH": (1, False, command_maplength),
1771 "WORLD_ACTIVE": (1, False, command_worldactive),
1772 "MAP": (2, False, setter_map("MAP")),
1773 "GAME_WON": (1, False, setter(None, "GAME_WON", 0, 1)), # #
1774 "SLIPPERS": (1, False, command_slippers), # #
1775 "TA_ID": (1, False, command_taid),
1776 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1777 "TA_NAME": (1, False, command_taname),
1778 "TT_ID": (1, False, command_ttid),
1779 "TT_NAME": (1, False, command_ttname),
1780 "TT_SYMBOL": (1, False, command_ttsymbol),
1781 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1782 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1784 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1786 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1788 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1789 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
1790 "T_ID": (1, False, command_tid),
1791 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1792 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1793 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1794 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1795 "T_COMMAND": (1, False, command_tcommand),
1796 "T_TYPE": (1, False, command_ttype),
1797 "T_CARRIES": (1, False, command_tcarries),
1798 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1799 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1800 "T_MEMTHING": (3, False, command_tmemthing),
1801 "T_POSY": (1, False, setter_tpos("Y")),
1802 "T_POSX": (1, False, setter_tpos("X")),
1803 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
1804 "wait": (0, False, play_commander("wait")),
1805 "move": (1, False, play_commander("move")),
1806 "pick_up": (0, False, play_commander("pick_up")),
1807 "drop": (1, False, play_commander("drop", True)),
1808 "use": (1, False, play_commander("use", True)),
1809 "ai": (0, False, command_ai)
1811 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1814 """World state database. With sane default values. (Randomness is in rand.)"""
1830 """Mapping of direction names to internal direction chars."""
1831 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1832 "west": "s", "north-west": "w", "north-east": "e"}
1834 """File IO database."""
1836 "path_save": "save",
1837 "path_record": "record_save",
1838 "path_worldconf": "confserver/world",
1839 "path_server": "server/",
1840 "path_in": "server/in",
1841 "path_out": "server/out",
1842 "path_worldstate": "server/worldstate",
1843 "tmp_suffix": "_tmp",
1844 "kicked_by_rival": False,
1845 "worldstate_updateable": False
1850 libpr = prep_library()
1851 rand = RandomnessIO()
1852 opts = parse_command_line_arguments()
1854 io_db["path_save"] = opts.savefile
1855 io_db["path_record"] = "record_" + opts.savefile
1858 io_db["verbose"] = True
1859 if None != opts.replay:
1863 except SystemExit as exit:
1864 print("ABORTING: " + exit.args[0])
1866 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")