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 draw_visible_Things(map, run):
312 for id in world_db["Things"]:
313 type = world_db["Things"][id]["T_TYPE"]
314 consumable = world_db["ThingTypes"][type]["TT_TOOL"] == "food"
315 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
316 if (0 == run and not consumable and not alive) \
317 or (1 == run and consumable and not alive) \
318 or (2 == run and alive):
319 y = world_db["Things"][id]["T_POSY"]
320 x = world_db["Things"][id]["T_POSX"]
321 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
322 if 'v' == chr(fovflag):
323 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
324 map[(y * length) + x] = ord(c)
326 def write_map(string, map):
327 for i in range(length):
328 line = map[i * length:(i * length) + length].decode()
329 string = string + line + "\n"
333 if [] == world_db["Things"][0]["T_CARRIES"]:
334 inventory = "(none)\n"
336 for id in world_db["Things"][0]["T_CARRIES"]:
337 type_id = world_db["Things"][id]["T_TYPE"]
338 name = world_db["ThingTypes"][type_id]["TT_NAME"]
339 inventory = inventory + name + "\n"
340 # 7DRL additions: GOD_MOOD, GOD_FAVOR
341 string = str(world_db["TURN"]) + "\n" + \
342 str(world_db["GOD_MOOD"]) + "\n" + \
343 str(world_db["GOD_FAVOR"]) + "\n" + \
344 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
345 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
346 inventory + "%\n" + \
347 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
348 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
349 str(world_db["MAP_LENGTH"]) + "\n"
350 length = world_db["MAP_LENGTH"]
351 fov = bytearray(b' ' * (length ** 2))
352 for pos in range(length ** 2):
353 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
354 fov[pos] = world_db["MAP"][pos]
356 draw_visible_Things(fov, i)
357 string = write_map(string, fov)
358 mem = world_db["Things"][0]["T_MEMMAP"][:]
360 for mt in world_db["Things"][0]["T_MEMTHING"]:
361 consumable = world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"
362 if (i == 0 and not consumable) or (i == 1 and consumable):
363 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
364 mem[(mt[1] * length) + mt[2]] = ord(c)
365 string = write_map(string, mem)
366 atomic_write(io_db["path_worldstate"], string, delete=False)
367 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
368 io_db["worldstate_updateable"] = False
372 """Replay game from record file.
374 Use opts.replay as breakpoint turn to which to replay automatically before
375 switching to manual input by non-meta commands in server input file
376 triggering further reads of record file. Ensure opts.replay is at least 1.
377 Run try_worldstate_update() before each interactive obey()/read_command().
381 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
382 " (if so late a turn is to be found).")
383 if not os.access(io_db["path_record"], os.F_OK):
384 raise SystemExit("No record file found to replay.")
385 io_db["file_record"] = open(io_db["path_record"], "r")
386 io_db["file_record"].prefix = "record file line "
387 io_db["file_record"].line_n = 1
388 while world_db["TURN"] < opts.replay:
389 line = io_db["file_record"].readline()
392 obey(line.rstrip(), io_db["file_record"].prefix
393 + str(io_db["file_record"].line_n))
394 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
396 try_worldstate_update()
397 obey(read_command(), "in file", replay=True)
401 """Play game by server input file commands. Before, load save file found.
403 If no save file is found, a new world is generated from the commands in the
404 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
405 command and all that follow via the server input file. Run
406 try_worldstate_update() before each interactive obey()/read_command().
408 if os.access(io_db["path_save"], os.F_OK):
409 obey_lines_in_file(io_db["path_save"], "save")
411 if not os.access(io_db["path_worldconf"], os.F_OK):
412 msg = "No world config file from which to start a new world."
413 raise SystemExit(msg)
414 obey_lines_in_file(io_db["path_worldconf"], "world config ",
416 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
418 try_worldstate_update()
419 obey(read_command(), "in file", do_record=True)
423 """(Re-)make island map.
425 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
426 start with one land cell in the middle, then go into cycle of repeatedly
427 selecting a random sea cell and transforming it into land if it is neighbor
428 to land. The cycle ends when a land cell is due to be created at the map's
429 border. Then put some trees on the map (TODO: more precise algorithm desc).
431 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
433 def is_neighbor(coordinates, type):
436 length = world_db["MAP_LENGTH"]
438 diag_west = x + (ind > 0)
439 diag_east = x + (ind < (length - 1))
440 pos = (y * length) + x
441 if (y > 0 and diag_east
442 and type == chr(world_db["MAP"][pos - length + ind])) \
444 and type == chr(world_db["MAP"][pos + 1])) \
445 or (y < (length - 1) and diag_east
446 and type == chr(world_db["MAP"][pos + length + ind])) \
447 or (y > 0 and diag_west
448 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
450 and type == chr(world_db["MAP"][pos - 1])) \
451 or (y < (length - 1) and diag_west
452 and type == chr(world_db["MAP"][pos + length - (not ind)])):
456 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
457 length = world_db["MAP_LENGTH"]
458 add_half_width = (not (length % 2)) * int(length / 2)
459 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
461 y = rand.next() % length
462 x = rand.next() % length
463 pos = (y * length) + x
464 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
465 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
467 world_db["MAP"][pos] = ord(".")
468 n_trees = int((length ** 2) / 16)
470 while (i_trees <= n_trees):
471 single_allowed = rand.next() % 32
472 y = rand.next() % length
473 x = rand.next() % length
474 pos = (y * length) + x
475 if "." == chr(world_db["MAP"][pos]) \
476 and ((not single_allowed) or is_neighbor((y, x), "X")):
477 world_db["MAP"][pos] = ord("X")
479 # This all-too-precise replica of the original C code misses iter_limit().
480 n_colons = int((length ** 2) / 16) # #
482 while (i_colons <= n_colons): # #
483 single_allowed = rand.next() % 256 # #
484 y = rand.next() % length # #
485 x = rand.next() % length # #
486 pos = (y * length) + x # #
487 if ("." == chr(world_db["MAP"][pos]) # #
488 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
489 world_db["MAP"][pos] = ord(":") # #
491 altar_placed = False # #
492 while not altar_placed: # #
493 y = rand.next() % length # #
494 x = rand.next() % length # #
495 pos = (y * length) + x # #
496 if (("." == chr(world_db["MAP"][pos] # #
497 or ":" == chr(world_db["MAP"][pos]))
498 and not is_neighbor((y, x), "X"))): # #
499 world_db["MAP"][pos] = ord("_") # #
500 world_db["altar"] = (y, x) # #
501 altar_placed = True # #
504 def update_map_memory(t, age_map=True):
505 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
507 def age_some_memdepthmap_on_nonfov_cells():
508 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
512 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
513 # if not ord_v == t["fovmap"][pos]
514 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
515 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
516 # if not rand.next() % (2 **
517 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
518 # t["T_MEMDEPTHMAP"][pos] += 1
519 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
520 fovmap = c_pointer_to_bytearray(t["fovmap"])
521 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
523 if not t["T_MEMMAP"]:
524 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
525 if not t["T_MEMDEPTHMAP"]:
526 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
530 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
531 if ord_v == t["fovmap"][pos]]:
532 t["T_MEMDEPTHMAP"][pos] = ord_0
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")
648 strong_write(io_db["file_out"],
649 "LOG See README on how to start over.\n")
652 t["T_MEMMAP"] = False
653 t["T_MEMDEPTHMAP"] = False
659 def add_gods_favor(i): # #
660 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
661 def favor_multiplier(i):
663 threshold = math.e * x
664 mood = world_db["GOD_MOOD"]
667 i = i * math.log(mood / x)
668 elif -mood > threshold:
669 i = i / math.log(-mood / x)
671 if -mood > threshold:
672 i = i * math.log(-mood / x)
674 i = i / math.log(mood / x)
676 world_db["GOD_FAVOR"] += favor_multiplier(i)
679 def mv_yx_in_dir_legal(dir, y, x):
680 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
681 dir_c = dir.encode("ascii")[0]
682 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
684 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
685 return (test, libpr.result_y(), libpr.result_x())
688 def enter_altar(): # #
689 """What happens when the player enters the altar."""
690 if world_db["FAVOR_STAGE"] > 9000:
691 strong_write(io_db["file_out"],
692 "LOG You step on a soul-less slab of stone.\n")
694 strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
695 if world_db["FAVOR_STAGE"] == 0:
696 world_db["FAVOR_STAGE"] = 1
697 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
698 + "\"I don't trust you. You intrude on the island's "
699 + "affairs. I think you're a nuisance at best, and a "
700 + "danger to my children at worst. I will give you a "
701 + "chance to lighten my mood, however: For a while now, "
702 + "I've been trying to spread the plant "
703 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
705 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
706 + "\"). I have not been very successful so far. Maybe "
707 + "you can make yourself useful there. I will count "
709 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
710 + " that grows to your favor.\n")
711 elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
712 world_db["FAVOR_STAGE"] = 2
713 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
714 + "\"You could have done worse so far. Maybe you are not "
715 + "the worst to happen to this island since the metal "
716 + "birds threw the great lightning ball. Maybe you can "
717 + "help me spread another plant. It multiplies faster, "
718 + "and it is highly nutritious: "
719 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
721 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_SYMBOL"]
722 + "\"). It is new. I give you the only example. Be very "
723 + "careful with it! I also give you another tool that "
724 + "might be helpful.\n")
725 id = id_setter(-1, "Things")
726 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
728 id = id_setter(-1, "Things")
729 world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
731 elif world_db["FAVOR_STAGE"] == 2 and \
732 0 == len([id for id in world_db["Things"]
733 if world_db["Things"][id]["T_TYPE"]
734 == world_db["PLANT_1"]]):
735 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
736 + "\"I am greatly disappointed that you lost all "
737 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
738 + " this island had. Here is another one. It cost me "
739 + " great work. Be more careful this time.\n")
740 id = id_setter(-1, "Things")
741 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
744 elif world_db["GOD_FAVOR"] > 9000:
745 world_db["FAVOR_STAGE"] = 9001
746 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
747 + "\"You have proven yourself worthy of my respect. "
748 + "You were a good citizen to the island, and sometimes "
749 + "a better steward to its inhabitants than me. The "
750 + "island shall miss you when you leave. But you have "
751 + "earned the right to do so. Take this "
752 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
753 + " and USE it when you please. It will take you to "
754 + "where you came from. (But do feel free to stay here "
755 + "as long as you like.)\"\n")
756 id = id_setter(-1, "Things")
757 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
762 """Make t do nothing (but loudly, if player avatar)."""
763 if t == world_db["Things"][0]:
764 strong_write(io_db["file_out"], "LOG You wait.\n")
768 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
769 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
770 # 7DRL: Player entering the altar triggers enter_altar().
771 # 7DRL: Player with axe chops down trees.
773 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
774 t["T_POSY"], t["T_POSX"])
775 if 1 == move_result[0]:
776 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
777 hitted = [id for id in world_db["Things"]
778 if world_db["Things"][id] != t
779 if world_db["Things"][id]["T_LIFEPOINTS"]
780 if world_db["Things"][id]["T_POSY"] == move_result[1]
781 if world_db["Things"][id]["T_POSX"] == move_result[2]]
784 if t == world_db["Things"][0]:
785 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
786 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
787 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
789 add_gods_favor(-1) # #
791 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
792 strong_write(io_db["file_out"], "LOG " + hitter_name +
794 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
795 if test and t == world_db["Things"][0]: # #
796 add_gods_favor(-test) # #
798 if (ord("X") == world_db["MAP"][pos] # #
799 or ord("|") == world_db["MAP"][pos]): # #
800 carries_axe = False # #
801 for id in t["T_CARRIES"]: # #
802 type = world_db["Things"][id]["T_TYPE"] # #
803 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # #
804 carries_axe = True # #
807 axe_name = world_db["ThingTypes"][type]["TT_NAME"] # #
808 if t == world_db["Things"][0]: # #
809 strong_write(io_db["file_out"], "LOG With your " # #
811 + ", you chop!\n") # #
812 add_gods_favor(-1) # #
813 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
814 case_X = world_db["MAP"][pos] == ord("X") # #
815 if (chop_power > 0 # #
817 0 == int(rand.next() / chop_power)) # #
818 or (not case_X and # #
819 0 == int(rand.next() / (3 * chop_power))))): # #
820 if t == world_db["Things"][0]: # #
821 strong_write(io_db["file_out"], # #
822 "LOG You chop it down.\n") # #
823 add_gods_favor(-10) # #
824 world_db["MAP"][pos] = ord(".") # #
825 i = 3 if case_X else 1 # #
826 for i in range(i): # #
827 id = id_setter(-1, "Things") # #
828 world_db["Things"][id] = \
829 new_Thing(world_db["LUMBER"], # #
830 (move_result[1], move_result[2])) # #
833 passable = ("." == chr(world_db["MAP"][pos]) or
834 ":" == chr(world_db["MAP"][pos]) or # #
835 "_" == chr(world_db["MAP"][pos])) # #
836 dir = [dir for dir in directions_db
837 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
839 t["T_POSY"] = move_result[1]
840 t["T_POSX"] = move_result[2]
841 for id in t["T_CARRIES"]:
842 world_db["Things"][id]["T_POSY"] = move_result[1]
843 world_db["Things"][id]["T_POSX"] = move_result[2]
845 if t == world_db["Things"][0]:
846 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
847 if (move_result[1] == world_db["altar"][0] and # #
848 move_result[2] == world_db["altar"][1]): # #
850 elif t == world_db["Things"][0]:
851 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
854 def actor_pick_up(t):
855 """Make t pick up (topmost?) Thing from ground into inventory."""
856 # Topmostness is actually not defined so far. Picks most nutritious Thing.
857 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
858 used_slots = len(t["T_CARRIES"]) # #
859 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
860 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
861 if not world_db["Things"][id]["carried"]
862 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
863 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
868 type = world_db["Things"][id]["T_TYPE"]
869 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
870 and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > nutritious:
871 nutritious = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
873 world_db["Things"][highest_id]["carried"] = True
874 type = world_db["Things"][highest_id]["T_TYPE"] # #
875 if (t != world_db["Things"][0] # #
876 and world_db["Things"][highest_id]["T_PLAYERDROP"] # #
877 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # #
878 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # #
879 add_gods_favor(score) # #
880 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0 # #
881 t["T_CARRIES"].append(highest_id)
882 if t == world_db["Things"][0]:
883 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
884 elif t == world_db["Things"][0]:
885 err = "You try to pick up an object, but there is none."
886 strong_write(io_db["file_out"], "LOG " + err + "\n")
887 elif t == world_db["Things"][0]: # #
888 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
889 "No storage room to carry more.\n") # #
893 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
894 # TODO: Handle case where T_ARGUMENT matches nothing.
895 if len(t["T_CARRIES"]):
896 id = t["T_CARRIES"][t["T_ARGUMENT"]]
897 t["T_CARRIES"].remove(id)
898 world_db["Things"][id]["carried"] = False
899 if t == world_db["Things"][0]:
900 strong_write(io_db["file_out"], "LOG You drop an object.\n")
901 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
902 elif t == world_db["Things"][0]:
903 err = "You try to drop an object, but you own none."
904 strong_write(io_db["file_out"], "LOG " + err + "\n")
908 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
909 # TODO: Handle case where T_ARGUMENT matches nothing.
910 # 7DLR: Handle SLIPPERS-type Thing use.
911 if len(t["T_CARRIES"]):
912 id = t["T_CARRIES"][t["T_ARGUMENT"]]
913 type = world_db["Things"][id]["T_TYPE"]
914 if type == world_db["SLIPPERS"]: # #
915 if t == world_db["Things"][0]: # #
916 strong_write(io_db["file_out"], "LOG You use the " # #
917 + world_db["ThingTypes"][type]["TT_NAME"] # #
918 + ". It glows in wondrous colors, and emits " # #
919 + "a sound as if from a dying cat. The " # #
920 + "Island God laughs.\n") # #
921 t["T_LIFEPOINTS"] = 1 # #
922 decrement_lifepoints(t) # #
923 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # #
924 and t == world_db["Things"][0]): # #
925 strong_write(io_db["file_out"], # #
926 "LOG To use this item for chopping, move " # #
927 "towards a tree while carrying it in " # #
928 "your inventory.\n") # #
929 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"): # #
930 pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
931 if (world_db["MAP"][pos] == ord("X") # #
932 or world_db["MAP"][pos] == ord("|")): # #
933 strong_write(io_db["file_out"], # #
934 "LOG Can't build when standing on barrier.\n") # #
936 for id in [id for id in world_db["Things"]
937 if not world_db["Things"][id] == t
938 if not world_db["Things"][id]["carried"]
939 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
940 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
941 strong_write(io_db["file_out"],
942 "LOG Can't build when standing objects.\n") # #
944 for id in t["T_CARRIES"]: # #
945 type_tool = world_db["Things"][id]["T_TYPE"] # #
946 if (world_db["ThingTypes"][type_tool]["TT_TOOL"] # #
950 for id in t["T_CARRIES"]: # #
951 type_material = world_db["Things"][id]["T_TYPE"] # #
952 if (world_db["ThingTypes"][type_material]["TT_TOOL"] # #
956 if wood_id != None: # #
957 t["T_CARRIES"].remove(wood_id) # #
958 del world_db["Things"][wood_id] # #
959 world_db["MAP"][pos] = ord("|") # #
960 strong_write(io_db["file_out"], "LOG With your " # #
961 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
962 + " you build a wooden barrier from your " # #
963 + world_db["ThingTypes"][type_material] # #
967 strong_write(io_db["file_out"], "LOG You can't use a " # #
968 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
969 + " without some wood in your inventory.\n") # #
970 elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
971 t["T_CARRIES"].remove(id)
972 del world_db["Things"][id]
973 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
974 if t == world_db["Things"][0]:
975 strong_write(io_db["file_out"],
976 "LOG You consume this object.\n")
977 elif t == world_db["Things"][0]:
978 strong_write(io_db["file_out"],
979 "LOG You try to use this object, but fail.\n")
980 elif t == world_db["Things"][0]:
981 strong_write(io_db["file_out"],
982 "LOG You try to use an object, but you own none.\n")
985 def thingproliferation(t, prol_map):
986 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
988 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
989 marked "." in prol_map. If there are several map cell candidates, one is
992 # 7DRL: success increments God's mood
993 # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
994 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
995 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
997 for dir in [directions_db[key] for key in directions_db]:
998 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
999 pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1000 if mv_result[0] and \
1001 (ord(":") == prol_map[pos] # #
1002 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1003 and ord(".") == prol_map[pos])):
1004 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1005 # * world_db["MAP_LENGTH"]
1007 candidates.append((mv_result[1], mv_result[2]))
1009 i = rand.next() % len(candidates)
1010 id = id_setter(-1, "Things")
1011 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1012 world_db["Things"][id] = newT
1013 animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1015 world_db["GOD_MOOD"] += animacy # #
1017 world_db["GOD_MOOD"] += 1 # #
1018 if (world_db["FAVOR_STAGE"] > 0 # #
1019 and t["T_TYPE"] == world_db["PLANT_0"]): # #
1020 world_db["GOD_FAVOR"] += 5 # #
1021 elif t["T_TYPE"] == world_db["PLANT_1"]: # #
1022 world_db["GOD_FAVOR"] += 25 # #
1026 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
1028 On success, decrease satiation score by 32.
1030 # 7DRL: Successful heals increment God's mood.
1031 if t["T_SATIATION"] > 0 \
1032 and t["T_LIFEPOINTS"] < \
1033 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
1034 and 0 == (rand.next() % 31) \
1035 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
1036 if world_db["ThingActions"][id]["TA_NAME"] ==
1038 t["T_LIFEPOINTS"] += 1
1039 world_db["GOD_MOOD"] += 1 # #
1040 t["T_SATIATION"] -= 32
1041 if t == world_db["Things"][0]:
1042 strong_write(io_db["file_out"], "LOG You heal.\n")
1046 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1047 if t["T_SATIATION"] > -32768:
1048 t["T_SATIATION"] -= 1
1049 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
1050 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1051 raise RuntimeError("A thing that should not hunger is hungering.")
1052 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
1053 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
1054 if t == world_db["Things"][0]:
1055 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
1056 decrement_lifepoints(t)
1059 def get_dir_to_target(t, filter):
1060 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1062 The path-wise nearest target is chosen, via the shortest available path.
1063 Target must not be t. On succcess, return positive value, else False.
1065 "a": Thing in FOV is below a certain distance, animate, but of ThingType
1066 that is not t's, and starts out weaker than t is; build path as
1067 avoiding things of t's ThingType
1068 "f": neighbor cell (not inhabited by any animate Thing) further away from
1069 animate Thing not further than x steps away and in FOV and of a
1070 ThingType that is not t's, and starts out stronger or as strong as t
1071 is currently; or (cornered), if no such flight cell, but Thing of
1072 above criteria is too near,1 a cell closer to it, or, if less near,
1074 "c": Thing in memorized map is consumable
1075 "s": memory map cell with greatest-reachable degree of unexploredness
1078 def zero_score_map_where_char_on_memdepthmap(c):
1079 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1080 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1081 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1082 # set_map_score(i, 0)
1083 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1084 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1085 raise RuntimeError("No score map allocated for "
1086 "zero_score_map_where_char_on_memdepthmap().")
1088 def set_map_score(pos, score):
1089 test = libpr.set_map_score(pos, score)
1091 raise RuntimeError("No score map allocated for set_map_score().")
1093 def get_map_score(pos):
1094 result = libpr.get_map_score(pos)
1096 raise RuntimeError("No score map allocated for get_map_score().")
1100 if t["fovmap"] and ("a" == filter or "f" == filter):
1101 for id in world_db["Things"]:
1102 Thing = world_db["Things"][id]
1103 if Thing != t and Thing["T_LIFEPOINTS"] and \
1104 t["T_TYPE"] != Thing["T_TYPE"] and \
1105 'v' == chr(t["fovmap"][(Thing["T_POSY"]
1106 * world_db["MAP_LENGTH"])
1107 + Thing["T_POSX"]]):
1108 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1109 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1110 t["T_LIFEPOINTS"]) \
1111 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1114 elif t["T_MEMMAP"] and "c" == filter:
1115 for mt in t["T_MEMTHING"]:
1116 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1118 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1122 def set_cells_passable_on_memmap_to_65534_on_scoremap():
1123 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1124 # ord_dot = ord(".")
1125 # memmap = t["T_MEMMAP"]
1126 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1127 # if ord_dot == memmap[i]]:
1128 # set_map_score(i, 65534) # i.e. 65535-1
1129 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1130 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1131 raise RuntimeError("No score map allocated for "
1132 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1134 def init_score_map():
1135 test = libpr.init_score_map()
1137 raise RuntimeError("Malloc error in init_score_map().")
1139 ord_blank = ord(" ")
1140 set_cells_passable_on_memmap_to_65534_on_scoremap()
1142 for id in world_db["Things"]:
1143 Thing = world_db["Things"][id]
1144 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1146 if t != Thing and Thing["T_LIFEPOINTS"] and \
1147 t["T_TYPE"] != Thing["T_TYPE"] and \
1148 ord_v == t["fovmap"][pos] and \
1149 t["T_LIFEPOINTS"] > \
1150 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1151 set_map_score(pos, 0)
1152 elif t["T_TYPE"] == Thing["T_TYPE"]:
1153 set_map_score(pos, 65535)
1155 for id in [id for id in world_db["Things"]
1156 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1157 Thing = world_db["Things"][id]
1158 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1160 if t["T_TYPE"] != Thing["T_TYPE"] and \
1161 ord_v == t["fovmap"][pos] and \
1162 t["T_LIFEPOINTS"] <= \
1163 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1164 set_map_score(pos, 0)
1166 for mt in [mt for mt in t["T_MEMTHING"]
1167 if ord_blank != t["T_MEMMAP"][mt[1]
1168 * world_db["MAP_LENGTH"]
1170 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1171 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1173 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1175 def rand_target_dir(neighbors, cmp, dirs):
1178 for i in range(len(dirs)):
1179 if cmp == neighbors[i]:
1180 candidates.append(dirs[i])
1182 return candidates[rand.next() % n_candidates] if n_candidates else 0
1184 def get_neighbor_scores(dirs, eye_pos):
1186 if libpr.ready_neighbor_scores(eye_pos):
1187 raise RuntimeError("No score map allocated for " +
1188 "ready_neighbor_scores.()")
1189 for i in range(len(dirs)):
1190 scores.append(libpr.get_neighbor_score(i))
1193 def get_dir_from_neighbors():
1194 dir_to_target = False
1196 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1197 neighbors = get_neighbor_scores(dirs, eye_pos)
1199 inhabited = [world_db["Things"][id]["T_POSY"]
1200 * world_db["MAP_LENGTH"]
1201 + world_db["Things"][id]["T_POSX"]
1202 for id in world_db["Things"]
1203 if world_db["Things"][id]["T_LIFEPOINTS"]]
1204 for i in range(len(dirs)):
1205 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1206 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1208 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1209 neighbors[i] = 65535
1211 minmax_start = 0 if "f" == filter else 65535 - 1
1212 minmax_neighbor = minmax_start
1213 for i in range(len(dirs)):
1214 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1215 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1216 or ("f" != filter and minmax_neighbor > neighbors[i]):
1217 minmax_neighbor = neighbors[i]
1218 if minmax_neighbor != minmax_start:
1219 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1221 if not dir_to_target:
1222 if 1 == get_map_score(eye_pos):
1223 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1224 elif 3 >= get_map_score(eye_pos):
1225 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1227 world_db["ThingActions"][id]["TA_NAME"]
1230 elif dir_to_target and 3 < get_map_score(eye_pos):
1232 elif "a" == filter and 10 <= get_map_score(eye_pos):
1234 return dir_to_target
1236 dir_to_target = False
1238 run_i = 9 + 1 if "s" == filter else 1
1239 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1242 mem_depth_c = b'9' if b' ' == mem_depth_c \
1243 else bytes([mem_depth_c[0] - 1])
1244 if libpr.dijkstra_map():
1245 raise RuntimeError("No score map allocated for dijkstra_map().")
1246 dir_to_target = get_dir_from_neighbors()
1247 libpr.free_score_map()
1248 if dir_to_target and str == type(dir_to_target):
1249 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1250 if world_db["ThingActions"][id]["TA_NAME"]
1252 t["T_ARGUMENT"] = ord(dir_to_target)
1253 return dir_to_target
1256 def standing_on_food(t):
1257 """Return True/False whether t is standing on a consumable."""
1258 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1259 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1260 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1261 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1262 ["TT_TOOL"] == "food"]:
1267 def get_inventory_slot_to_consume(t):
1268 """Return slot Id of strongest consumable in t's inventory, else -1."""
1272 for id in t["T_CARRIES"]:
1273 type = world_db["Things"][id]["T_TYPE"]
1274 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1275 and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > cmp_food:
1276 cmp_food = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1283 """Determine next command/argment for actor t via AI algorithms.
1285 AI will look for, and move towards, enemies (animate Things not of their
1286 own ThingType); if they see none, they will consume consumables in their
1287 inventory; if there are none, they will pick up what they stand on if they
1288 stand on consumables; if they stand on none, they will move towards the
1289 next consumable they see or remember on the map; if they see or remember
1290 none, they will explore parts of the map unseen since ever or for at least
1291 one turn; if there is nothing to explore, they will simply wait.
1293 # 7DRL add: Don't pick up or search things when inventory is full.
1294 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1295 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1296 if not get_dir_to_target(t, "f"):
1297 sel = get_inventory_slot_to_consume(t)
1299 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1300 if world_db["ThingActions"][id]["TA_NAME"]
1302 t["T_ARGUMENT"] = sel
1303 elif standing_on_food(t) \
1304 and (len(t["T_CARRIES"]) < # #
1305 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1306 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1307 if world_db["ThingActions"][id]["TA_NAME"]
1310 (len(t["T_CARRIES"]) < # #
1311 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1312 and get_dir_to_target(t, "c"))) and \
1313 (not get_dir_to_target(t, "a")):
1314 get_dir_to_target(t, "s")
1318 """Run game world and its inhabitants until new player input expected."""
1320 whilebreaker = False
1321 while world_db["Things"][0]["T_LIFEPOINTS"]:
1322 proliferable_map = world_db["MAP"][:]
1323 for id in [id for id in world_db["Things"]
1324 if not world_db["Things"][id]["carried"]]:
1325 y = world_db["Things"][id]["T_POSY"]
1326 x = world_db["Things"][id]["T_POSX"]
1327 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1328 for id in [id for id in world_db["Things"]]: # Only what's from start!
1329 if not id in world_db["Things"] or \
1330 world_db["Things"][id]["carried"]: # May have been consumed or
1331 continue # picked up during turn …
1332 Thing = world_db["Things"][id]
1333 if Thing["T_LIFEPOINTS"]:
1334 if not Thing["T_COMMAND"]:
1335 update_map_memory(Thing)
1342 if Thing["T_LIFEPOINTS"]:
1343 Thing["T_PROGRESS"] += 1
1344 taid = [a for a in world_db["ThingActions"]
1345 if a == Thing["T_COMMAND"]][0]
1346 ThingAction = world_db["ThingActions"][taid]
1347 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1348 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1349 Thing["T_COMMAND"] = 0
1350 Thing["T_PROGRESS"] = 0
1351 thingproliferation(Thing, proliferable_map)
1354 world_db["TURN"] += 1
1357 def new_Thing(type, pos=(0, 0)):
1358 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1360 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1365 "T_PLAYERDROP": 0, # #
1373 "T_MEMDEPTHMAP": False,
1376 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1377 build_fov_map(thing)
1381 def id_setter(id, category, id_store=False, start_at_1=False):
1382 """Set ID of object of category to manipulate ID unused? Create new one.
1384 The ID is stored as id_store.id (if id_store is set). If the integer of the
1385 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1386 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1387 always returned when no new object is created, otherwise the new object's
1390 min = 0 if start_at_1 else -1
1392 id = integer_test(id, min)
1394 if id in world_db[category]:
1399 if (start_at_1 and 0 == id) \
1400 or ((not start_at_1) and (id < 0)):
1401 id = 0 if start_at_1 else -1
1404 if id not in world_db[category]:
1412 """Send PONG line to server output file."""
1413 strong_write(io_db["file_out"], "PONG\n")
1417 """Abort server process."""
1418 if None == opts.replay:
1419 if world_db["WORLD_ACTIVE"]:
1421 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1422 raise SystemExit("received QUIT command")
1425 def command_thingshere(str_y, str_x):
1426 """Write to out file list of Things known to player at coordinate y, x."""
1427 if world_db["WORLD_ACTIVE"]:
1428 y = integer_test(str_y, 0, 255)
1429 x = integer_test(str_x, 0, 255)
1430 length = world_db["MAP_LENGTH"]
1431 if None != y and None != x and y < length and x < length:
1432 pos = (y * world_db["MAP_LENGTH"]) + x
1433 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1434 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1435 for id in world_db["Things"]:
1436 if y == world_db["Things"][id]["T_POSY"] \
1437 and x == world_db["Things"][id]["T_POSX"] \
1438 and not world_db["Things"][id]["carried"]:
1439 type = world_db["Things"][id]["T_TYPE"]
1440 name = world_db["ThingTypes"][type]["TT_NAME"]
1441 strong_write(io_db["file_out"], name + "\n")
1443 for mt in world_db["Things"][0]["T_MEMTHING"]:
1444 if y == mt[1] and x == mt[2]:
1445 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1446 strong_write(io_db["file_out"], name + "\n")
1447 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1449 print("Ignoring: Invalid map coordinates.")
1451 print("Ignoring: Command only works on existing worlds.")
1454 def play_commander(action, args=False):
1455 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1457 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1461 id = [x for x in world_db["ThingActions"]
1462 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1463 world_db["Things"][0]["T_COMMAND"] = id
1466 def set_command_and_argument_int(str_arg):
1467 val = integer_test(str_arg, 0, 255)
1469 world_db["Things"][0]["T_ARGUMENT"] = val
1472 def set_command_and_argument_movestring(str_arg):
1473 if str_arg in directions_db:
1474 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1477 print("Ignoring: Argument must be valid direction string.")
1479 if action == "move":
1480 return set_command_and_argument_movestring
1482 return set_command_and_argument_int
1487 def command_seedrandomness(seed_string):
1488 """Set rand seed to int(seed_string)."""
1489 val = integer_test(seed_string, 0, 4294967295)
1494 def command_makeworld(seed_string):
1495 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1497 Seed rand with seed. Do more only with a "wait" ThingAction and
1498 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1499 world_db["Things"] emptied, call make_map() and set
1500 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1501 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1502 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1503 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1507 # def free_pos(plant=False):
1508 def free_pos(plant=False): # #
1511 err = "Space to put thing on too hard to find. Map too small?"
1513 y = rand.next() % world_db["MAP_LENGTH"]
1514 x = rand.next() % world_db["MAP_LENGTH"]
1515 pos = y * world_db["MAP_LENGTH"] + x;
1517 and "." == chr(world_db["MAP"][pos])) \
1518 or ":" == chr(world_db["MAP"][pos]): # #
1522 raise SystemExit(err)
1523 # Replica of C code, wrongly ignores animatedness of new Thing.
1524 pos_clear = (0 == len([id for id in world_db["Things"]
1525 if world_db["Things"][id]["T_LIFEPOINTS"]
1526 if world_db["Things"][id]["T_POSY"] == y
1527 if world_db["Things"][id]["T_POSX"] == x]))
1532 val = integer_test(seed_string, 0, 4294967295)
1536 player_will_be_generated = False
1537 playertype = world_db["PLAYER_TYPE"]
1538 for ThingType in world_db["ThingTypes"]:
1539 if playertype == ThingType:
1540 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1541 player_will_be_generated = True
1543 if not player_will_be_generated:
1544 print("Ignoring: No player type with start number >0 defined.")
1547 for ThingAction in world_db["ThingActions"]:
1548 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1551 print("Ignoring: No thing action with name 'wait' defined.")
1553 for name in specials: # #
1554 if world_db[name] not in world_db["ThingTypes"]: # #
1555 print("Ignoring: No valid " + name + " set.") # #
1557 world_db["Things"] = {}
1559 world_db["WORLD_ACTIVE"] = 1
1560 world_db["TURN"] = 1
1561 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1562 id = id_setter(-1, "Things")
1563 world_db["Things"][id] = new_Thing(playertype, free_pos())
1564 if not world_db["Things"][0]["fovmap"]:
1565 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1566 world_db["Things"][0]["fovmap"] = empty_fovmap
1567 update_map_memory(world_db["Things"][0])
1568 for type in world_db["ThingTypes"]:
1569 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1570 if type != playertype:
1571 id = id_setter(-1, "Things")
1572 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1573 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1574 strong_write(io_db["file_out"], "NEW_WORLD\n")
1578 def command_maplength(maplength_string):
1579 """Redefine map length. Invalidate map, therefore lose all things on it."""
1580 val = integer_test(maplength_string, 1, 256)
1582 world_db["MAP_LENGTH"] = val
1583 world_db["MAP"] = False
1584 set_world_inactive()
1585 world_db["Things"] = {}
1586 libpr.set_maplength(val)
1589 def command_worldactive(worldactive_string):
1590 """Toggle world_db["WORLD_ACTIVE"] if possible.
1592 An active world can always be set inactive. An inactive world can only be
1593 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1594 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1595 Also call log_help().
1597 # 7DRL: altar must be on map, and specials must be set for active world.
1598 val = integer_test(worldactive_string, 0, 1)
1600 if 0 != world_db["WORLD_ACTIVE"]:
1602 set_world_inactive()
1604 print("World already active.")
1605 elif 0 == world_db["WORLD_ACTIVE"]:
1607 for ThingAction in world_db["ThingActions"]:
1608 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1611 player_exists = False
1612 for Thing in world_db["Things"]:
1614 player_exists = True
1616 specials_set = True # #
1617 for name in specials: # #
1618 if world_db[name] not in world_db["ThingTypes"]: # #
1619 specials_set = False # #
1620 altar_found = False # #
1621 if world_db["MAP"]: # #
1622 pos = world_db["MAP"].find(b'_') # #
1624 y = int(pos / world_db["MAP_LENGTH"]) # #
1625 x = pos % world_db["MAP_LENGTH"] # #
1626 world_db["altar"] = (y, x) # #
1627 altar_found = True # #
1628 if wait_exists and player_exists and world_db["MAP"] \
1629 and specials_set: # #
1630 for id in world_db["Things"]:
1631 if world_db["Things"][id]["T_LIFEPOINTS"]:
1632 build_fov_map(world_db["Things"][id])
1634 update_map_memory(world_db["Things"][id], False)
1635 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1636 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1637 world_db["Things"][0]["fovmap"] = empty_fovmap
1638 world_db["WORLD_ACTIVE"] = 1
1641 print("Ignoring: Not all conditions for world activation met.")
1644 def specialtypesetter(name): # #
1645 """Setter world_db[name], deactivating world if set int no ThingType."""
1646 def helper(str_int):
1647 val = integer_test(str_int, 0)
1649 world_db[name] = val
1650 if world_db["WORLD_ACTIVE"] \
1651 and world_db[name] not in world_db["ThingTypes"]:
1652 world_db["WORLD_ACTIVE"] = 0
1653 print(name + " fits no known ThingType, deactivating world.")
1657 def test_for_id_maker(object, category):
1658 """Return decorator testing for object having "id" attribute."""
1661 if hasattr(object, "id"):
1664 print("Ignoring: No " + category +
1665 " defined to manipulate yet.")
1670 def command_tid(id_string):
1671 """Set ID of Thing to manipulate. ID unused? Create new one.
1673 Default new Thing's type to the first available ThingType, others: zero.
1675 id = id_setter(id_string, "Things", command_tid)
1677 if world_db["ThingTypes"] == {}:
1678 print("Ignoring: No ThingType to settle new Thing in.")
1680 type = list(world_db["ThingTypes"].keys())[0]
1681 world_db["Things"][id] = new_Thing(type)
1684 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1688 def command_tcommand(str_int):
1689 """Set T_COMMAND of selected Thing."""
1690 val = integer_test(str_int, 0)
1692 if 0 == val or val in world_db["ThingActions"]:
1693 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1695 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1699 def command_ttype(str_int):
1700 """Set T_TYPE of selected Thing."""
1701 val = integer_test(str_int, 0)
1703 if val in world_db["ThingTypes"]:
1704 world_db["Things"][command_tid.id]["T_TYPE"] = val
1706 print("Ignoring: ThingType ID belongs to no known ThingType.")
1710 def command_tcarries(str_int):
1711 """Append int(str_int) to T_CARRIES of selected Thing.
1713 The ID int(str_int) must not be of the selected Thing, and must belong to a
1714 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1716 val = integer_test(str_int, 0)
1718 if val == command_tid.id:
1719 print("Ignoring: Thing cannot carry itself.")
1720 elif val in world_db["Things"] \
1721 and not world_db["Things"][val]["carried"]:
1722 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1723 world_db["Things"][val]["carried"] = True
1725 print("Ignoring: Thing not available for carrying.")
1726 # Note that the whole carrying structure is different from the C version:
1727 # Carried-ness is marked by a "carried" flag, not by Things containing
1728 # Things internally.
1732 def command_tmemthing(str_t, str_y, str_x):
1733 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1735 The type must fit to an existing ThingType, and the position into the map.
1737 type = integer_test(str_t, 0)
1738 posy = integer_test(str_y, 0, 255)
1739 posx = integer_test(str_x, 0, 255)
1740 if None != type and None != posy and None != posx:
1741 if type not in world_db["ThingTypes"] \
1742 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1743 print("Ignoring: Illegal value for thing type or position.")
1745 memthing = (type, posy, posx)
1746 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1749 def setter_map(maptype):
1750 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1752 If no map of maptype exists yet, initialize it with ' ' bytes first.
1755 def valid_map_line(str_int, mapline):
1756 val = integer_test(str_int, 0, 255)
1758 if val >= world_db["MAP_LENGTH"]:
1759 print("Illegal value for map line number.")
1760 elif len(mapline) != world_db["MAP_LENGTH"]:
1761 print("Map line length is unequal map width.")
1766 def nonThingMap_helper(str_int, mapline):
1767 val = valid_map_line(str_int, mapline)
1769 length = world_db["MAP_LENGTH"]
1770 if not world_db["MAP"]:
1771 map = bytearray(b' ' * (length ** 2))
1773 map = world_db["MAP"]
1774 map[val * length:(val * length) + length] = mapline.encode()
1775 if not world_db["MAP"]:
1776 world_db["MAP"] = map
1779 def ThingMap_helper(str_int, mapline):
1780 val = valid_map_line(str_int, mapline)
1782 length = world_db["MAP_LENGTH"]
1783 if not world_db["Things"][command_tid.id][maptype]:
1784 map = bytearray(b' ' * (length ** 2))
1786 map = world_db["Things"][command_tid.id][maptype]
1787 map[val * length:(val * length) + length] = mapline.encode()
1788 if not world_db["Things"][command_tid.id][maptype]:
1789 world_db["Things"][command_tid.id][maptype] = map
1791 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1794 def setter_tpos(axis):
1795 """Generate setter for T_POSX or T_POSY of selected Thing.
1797 If world is active, rebuilds animate things' fovmap, player's memory map.
1800 def helper(str_int):
1801 val = integer_test(str_int, 0, 255)
1803 if val < world_db["MAP_LENGTH"]:
1804 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1805 if world_db["WORLD_ACTIVE"] \
1806 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1807 build_fov_map(world_db["Things"][command_tid.id])
1808 if 0 == command_tid.id:
1809 update_map_memory(world_db["Things"][command_tid.id])
1811 print("Ignoring: Position is outside of map.")
1815 def command_ttid(id_string):
1816 """Set ID of ThingType to manipulate. ID unused? Create new one.
1818 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1821 id = id_setter(id_string, "ThingTypes", command_ttid)
1823 world_db["ThingTypes"][id] = {
1824 "TT_NAME": "(none)",
1827 "TT_PROLIFERATE": 0,
1828 "TT_START_NUMBER": 0,
1829 "TT_STORAGE": 0, # #
1836 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1840 def command_ttname(name):
1841 """Set TT_NAME of selected ThingType."""
1842 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1846 def command_tttool(name):
1847 """Set TT_TOOL of selected ThingType."""
1848 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1852 def command_ttsymbol(char):
1853 """Set TT_SYMBOL of selected ThingType. """
1855 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1857 print("Ignoring: Argument must be single character.")
1861 def command_ttcorpseid(str_int):
1862 """Set TT_CORPSE_ID of selected ThingType."""
1863 val = integer_test(str_int, 0)
1865 if val in world_db["ThingTypes"]:
1866 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1868 print("Ignoring: Corpse ID belongs to no known ThignType.")
1871 def command_taid(id_string):
1872 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1874 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1876 id = id_setter(id_string, "ThingActions", command_taid, True)
1878 world_db["ThingActions"][id] = {
1884 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1887 @test_ThingAction_id
1888 def command_taname(name):
1889 """Set TA_NAME of selected ThingAction.
1891 The name must match a valid thing action function. If after the name
1892 setting no ThingAction with name "wait" remains, call set_world_inactive().
1894 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1895 or name == "pick_up":
1896 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1897 if 1 == world_db["WORLD_ACTIVE"]:
1898 wait_defined = False
1899 for id in world_db["ThingActions"]:
1900 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1903 if not wait_defined:
1904 set_world_inactive()
1906 print("Ignoring: Invalid action name.")
1907 # In contrast to the original,naming won't map a function to a ThingAction.
1911 """Call ai() on player Thing, then turn_over()."""
1912 ai(world_db["Things"][0])
1916 """Commands database.
1918 Map command start tokens to ([0]) number of expected command arguments, ([1])
1919 the command's meta-ness (i.e. is it to be written to the record file, is it to
1920 be ignored in replay mode if read from server input file), and ([2]) a function
1924 "QUIT": (0, True, command_quit),
1925 "PING": (0, True, command_ping),
1926 "THINGS_HERE": (2, True, command_thingshere),
1927 "MAKE_WORLD": (1, False, command_makeworld),
1928 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1929 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1930 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1931 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1932 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1933 "MAP_LENGTH": (1, False, command_maplength),
1934 "WORLD_ACTIVE": (1, False, command_worldactive),
1935 "MAP": (2, False, setter_map("MAP")),
1936 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
1937 "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")), # #
1938 "PLANT_0": (1, False, specialtypesetter("PLANT_0")), # #
1939 "PLANT_1": (1, False, specialtypesetter("PLANT_1")), # #
1940 "LUMBER": (1, False, specialtypesetter("LUMBER")), # #
1941 "TOOL_0": (1, False, specialtypesetter("TOOL_0")), # #
1942 "TA_ID": (1, False, command_taid),
1943 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1944 "TA_NAME": (1, False, command_taname),
1945 "TT_ID": (1, False, command_ttid),
1946 "TT_NAME": (1, False, command_ttname),
1947 "TT_TOOL": (1, False, command_tttool),
1948 "TT_SYMBOL": (1, False, command_ttsymbol),
1949 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1950 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1951 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1953 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1955 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1956 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
1957 "T_ID": (1, False, command_tid),
1958 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1959 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1960 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1961 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1962 "T_COMMAND": (1, False, command_tcommand),
1963 "T_TYPE": (1, False, command_ttype),
1964 "T_CARRIES": (1, False, command_tcarries),
1965 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1966 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1967 "T_MEMTHING": (3, False, command_tmemthing),
1968 "T_POSY": (1, False, setter_tpos("Y")),
1969 "T_POSX": (1, False, setter_tpos("X")),
1970 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
1971 "wait": (0, False, play_commander("wait")),
1972 "move": (1, False, play_commander("move")),
1973 "pick_up": (0, False, play_commander("pick_up")),
1974 "drop": (1, False, play_commander("drop", True)),
1975 "use": (1, False, play_commander("use", True)),
1976 "ai": (0, False, command_ai)
1978 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
1981 """World state database. With sane default values. (Randomness is in rand.)"""
1990 "FAVOR_STAGE": 0, # #
2002 """Special type settings."""
2003 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"] # #
2005 """Mapping of direction names to internal direction chars."""
2006 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2007 "west": "s", "north-west": "w", "north-east": "e"}
2009 """File IO database."""
2011 "path_save": "save",
2012 "path_record": "record_save",
2013 "path_worldconf": "confserver/world",
2014 "path_server": "server/",
2015 "path_in": "server/in",
2016 "path_out": "server/out",
2017 "path_worldstate": "server/worldstate",
2018 "tmp_suffix": "_tmp",
2019 "kicked_by_rival": False,
2020 "worldstate_updateable": False
2025 libpr = prep_library()
2026 rand = RandomnessIO()
2027 opts = parse_command_line_arguments()
2029 io_db["path_save"] = opts.savefile
2030 io_db["path_record"] = "record_" + opts.savefile
2033 io_db["verbose"] = True
2034 if None != opts.replay:
2038 except SystemExit as exit:
2039 print("ABORTING: " + exit.args[0])
2041 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")