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()
103 """Send "msg" to log."""
104 strong_write(io_db["file_out"], "LOG " + msg + "\n")
107 def obey(command, prefix, replay=False, do_record=False):
108 """Call function from commands_db mapped to command's first token.
110 Tokenize command string with shlex.split(comments=True). If replay is set,
111 a non-meta command from the commands_db merely triggers obey() on the next
112 command from the records file. If not, non-meta commands set
113 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
114 do_record is set, are recorded to io_db["record_chunk"], and save_world()
115 is called (and io_db["record_chunk"] written) if 15 seconds have passed
116 since the last time it was called. The prefix string is inserted into the
117 server's input message between its beginning 'input ' and ':'. All activity
118 is preceded by a server_test() call. Commands that start with a lowercase
119 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
123 print("input " + prefix + ": " + command)
125 tokens = shlex.split(command, comments=True)
126 except ValueError as err:
127 print("Can't tokenize command string: " + str(err) + ".")
129 if len(tokens) > 0 and tokens[0] in commands_db \
130 and len(tokens) == commands_db[tokens[0]][0] + 1:
131 if commands_db[tokens[0]][1]:
132 commands_db[tokens[0]][2](*tokens[1:])
133 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
134 print("Ignoring lowercase-starting commands when world inactive.")
136 print("Due to replay mode, reading command as 'go on in record'.")
137 line = io_db["file_record"].readline()
139 obey(line.rstrip(), io_db["file_record"].prefix
140 + str(io_db["file_record"].line_n))
141 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
143 print("Reached end of record file.")
145 commands_db[tokens[0]][2](*tokens[1:])
147 io_db["record_chunk"] += command + "\n"
148 if time.time() > io_db["save_wait"] + 15:
149 atomic_write(io_db["path_record"], io_db["record_chunk"],
151 if world_db["WORLD_ACTIVE"]:
153 io_db["record_chunk"] = ""
154 io_db["save_wait"] = time.time()
155 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
156 elif 0 != len(tokens):
157 print("Invalid command/argument, or bad number of tokens.")
160 def atomic_write(path, text, do_append=False, delete=True):
161 """Atomic write of text to file at path, appended if do_append is set."""
162 path_tmp = path + io_db["tmp_suffix"]
166 if os.access(path, os.F_OK):
167 shutil.copyfile(path, path_tmp)
168 file = open(path_tmp, mode)
169 strong_write(file, text)
171 if delete and os.access(path, os.F_OK):
173 os.rename(path_tmp, path)
177 """Save all commands needed to reconstruct current world state."""
180 string = string.replace("\u005C", '\u005C\u005C')
181 return '"' + string.replace('"', '\u005C"') + '"'
186 if key == "MAP" or world_db["Things"][id][key]:
187 map = world_db["MAP"] if key == "MAP" \
188 else world_db["Things"][id][key]
189 length = world_db["MAP_LENGTH"]
190 for i in range(length):
191 line = map[i * length:(i * length) + length].decode()
192 string = string + key + " " + str(i) + " " + quote(line) \
199 for memthing in world_db["Things"][id]["T_MEMTHING"]:
200 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
201 str(memthing[1]) + " " + str(memthing[2]) + "\n"
204 def helper(category, id_string, special_keys={}):
206 for id in world_db[category]:
207 string = string + id_string + " " + str(id) + "\n"
208 for key in world_db[category][id]:
209 if not key in special_keys:
210 x = world_db[category][id][key]
211 argument = quote(x) if str == type(x) else str(x)
212 string = string + key + " " + argument + "\n"
213 elif special_keys[key]:
214 string = string + special_keys[key](id)
219 if (dict != type(world_db[key])
220 and key != "altar" # #
221 and key != "MAP" and key != "WORLD_ACTIVE"):
222 string = string + key + " " + str(world_db[key]) + "\n"
223 string = string + mapsetter("MAP")()
224 string = string + helper("ThingActions", "TA_ID")
225 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
226 for id in world_db["ThingTypes"]:
227 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
228 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
229 string = string + helper("Things", "T_ID",
230 {"T_CARRIES": False, "carried": False,
231 "T_MEMMAP": mapsetter("T_MEMMAP"),
232 "T_MEMTHING": memthing, "fovmap": False,
233 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
234 for id in world_db["Things"]:
235 if [] != world_db["Things"][id]["T_CARRIES"]:
236 string = string + "T_ID " + str(id) + "\n"
237 for carried_id in world_db["Things"][id]["T_CARRIES"]:
238 string = string + "T_CARRIES " + str(carried_id) + "\n"
239 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
240 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
241 atomic_write(io_db["path_save"], string)
244 def obey_lines_in_file(path, name, do_record=False):
245 """Call obey() on each line of path's file, use name in input prefix."""
246 file = open(path, "r")
248 for line in file.readlines():
249 obey(line.rstrip(), name + "file line " + str(line_n),
255 def parse_command_line_arguments():
256 """Return settings values read from command line arguments."""
257 parser = argparse.ArgumentParser()
258 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
260 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
262 parser.add_argument('-v', dest='verbose', action='store_true')
263 opts, unknown = parser.parse_known_args()
268 """Ensure valid server out file belonging to current process.
270 This is done by comparing io_db["teststring"] to what's found at the start
271 of the current file at io_db["path_out"]. On failure, set
272 io_db["kicked_by_rival"] and raise SystemExit.
274 if not os.access(io_db["path_out"], os.F_OK):
275 raise SystemExit("Server output file has disappeared.")
276 file = open(io_db["path_out"], "r")
277 test = file.readline().rstrip("\n")
279 if test != io_db["teststring"]:
280 io_db["kicked_by_rival"] = True
281 msg = "Server test string in server output file does not match. This" \
282 " indicates that the current server process has been " \
283 "superseded by another one."
284 raise SystemExit(msg)
288 """Return next newline-delimited command from server in file.
290 Keep building return string until a newline is encountered. Pause between
291 unsuccessful reads, and after too much waiting, run server_test().
293 wait_on_fail = 0.03333
298 add = io_db["file_in"].readline()
300 command = command + add
301 if len(command) > 0 and "\n" == command[-1]:
302 command = command[:-1]
305 time.sleep(wait_on_fail)
306 if now + max_wait < time.time():
312 def try_worldstate_update():
313 """Write worldstate file if io_db["worldstate_updateable"] is set."""
314 if io_db["worldstate_updateable"]:
316 def write_map(string, map):
317 for i in range(length):
318 line = map[i * length:(i * length) + length].decode()
319 string = string + line + "\n"
323 if [] == world_db["Things"][0]["T_CARRIES"]:
324 inventory = "(none)\n"
326 for id in world_db["Things"][0]["T_CARRIES"]:
327 type_id = world_db["Things"][id]["T_TYPE"]
328 name = world_db["ThingTypes"][type_id]["TT_NAME"]
329 inventory = inventory + name + "\n"
330 # 7DRL additions: GOD_MOOD, GOD_FAVOR
331 string = str(world_db["TURN"]) + "\n" + \
332 str(world_db["GOD_MOOD"]) + "\n" + \
333 str(world_db["GOD_FAVOR"]) + "\n" + \
334 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
335 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
336 inventory + "%\n" + \
337 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
338 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
339 str(world_db["MAP_LENGTH"]) + "\n"
340 length = world_db["MAP_LENGTH"]
342 fov = bytearray(b' ' * (length ** 2))
344 for pos in [pos for pos in range(length ** 2)
345 if ord_v == world_db["Things"][0]["fovmap"][pos]]:
346 fov[pos] = world_db["MAP"][pos]
347 for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
348 for id in world_db["Things"]
349 if not world_db["Things"][id]["carried"]
350 if world_db["Things"][id]["T_TYPE"] == tid
351 if world_db["Things"][0]["fovmap"][
352 world_db["Things"][id]["T_POSY"] * length
353 + world_db["Things"][id]["T_POSX"]] == ord_v]:
354 type = world_db["Things"][id]["T_TYPE"]
355 c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
356 fov[world_db["Things"][id]["T_POSY"] * length
357 + world_db["Things"][id]["T_POSX"]] = c
358 string = write_map(string, fov)
360 mem = world_db["Things"][0]["T_MEMMAP"][:]
361 for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
362 for mt in world_db["Things"][0]["T_MEMTHING"]
364 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
365 mem[(mt[1] * length) + mt[2]] = ord(c)
366 string = write_map(string, mem)
368 metamapA = bytearray(b'0' * (length ** 2)) # #
369 for id in [id for id in world_db["Things"] # #
370 if not world_db["Things"][id]["carried"] # #
371 if world_db["Things"][id]["T_LIFEPOINTS"] # #
372 if world_db["Things"][0]["fovmap"][ # #
373 world_db["Things"][id]["T_POSY"] * length # #
374 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
375 pos = (world_db["Things"][id]["T_POSY"] * length # #
376 + world_db["Things"][id]["T_POSX"]) # #
377 if id == 0 or world_db["EMPATHY"]: # #
378 type = world_db["Things"][id]["T_TYPE"] # #
379 max_hp = world_db["ThingTypes"][type]["TT_LIFEPOINTS"] # #
380 third_of_hp = max_hp / 3 # #
381 hp = world_db["Things"][id]["T_LIFEPOINTS"] # #
383 if hp > 2 * third_of_hp: # #
385 elif hp > third_of_hp: # #
387 metamapA[pos] = ord('a') + add # #
389 metamapA[pos] = ord('X') # #
390 for mt in world_db["Things"][0]["T_MEMTHING"]: # #
391 pos = mt[1] * length + mt[2] # #
392 if metamapA[pos] < ord('2'): # #
393 metamapA[pos] += 1 # #
394 string = write_map(string, metamapA) # #
396 metamapB = bytearray(b' ' * (length ** 2)) # #
397 for id in [id for id in world_db["Things"] # #
398 if not world_db["Things"][id]["carried"] # #
399 if world_db["Things"][id]["T_LIFEPOINTS"] # #
400 if world_db["Things"][0]["fovmap"][ # #
401 world_db["Things"][id]["T_POSY"] * length # #
402 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
403 pos = (world_db["Things"][id]["T_POSY"] * length # #
404 + world_db["Things"][id]["T_POSX"]) # #
405 if id == 0 or world_db["EMPATHY"]: # #
406 action = world_db["Things"][id]["T_COMMAND"] # #
408 name = world_db["ThingActions"][action]["TA_NAME"] # #
411 metamapB[pos] = ord(name[0]) # #
412 string = write_map(string, metamapB) # #
414 atomic_write(io_db["path_worldstate"], string, delete=False)
415 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
416 io_db["worldstate_updateable"] = False
420 """Replay game from record file.
422 Use opts.replay as breakpoint turn to which to replay automatically before
423 switching to manual input by non-meta commands in server input file
424 triggering further reads of record file. Ensure opts.replay is at least 1.
425 Run try_worldstate_update() before each interactive obey()/read_command().
429 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
430 " (if so late a turn is to be found).")
431 if not os.access(io_db["path_record"], os.F_OK):
432 raise SystemExit("No record file found to replay.")
433 io_db["file_record"] = open(io_db["path_record"], "r")
434 io_db["file_record"].prefix = "record file line "
435 io_db["file_record"].line_n = 1
436 while world_db["TURN"] < opts.replay:
437 line = io_db["file_record"].readline()
440 obey(line.rstrip(), io_db["file_record"].prefix
441 + str(io_db["file_record"].line_n))
442 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
444 try_worldstate_update()
445 obey(read_command(), "in file", replay=True)
449 """Play game by server input file commands. Before, load save file found.
451 If no save file is found, a new world is generated from the commands in the
452 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
453 command and all that follow via the server input file. Run
454 try_worldstate_update() before each interactive obey()/read_command().
456 if os.access(io_db["path_save"], os.F_OK):
457 obey_lines_in_file(io_db["path_save"], "save")
459 if not os.access(io_db["path_worldconf"], os.F_OK):
460 msg = "No world config file from which to start a new world."
461 raise SystemExit(msg)
462 obey_lines_in_file(io_db["path_worldconf"], "world config ",
464 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
466 try_worldstate_update()
467 obey(read_command(), "in file", do_record=True)
471 """(Re-)make island map.
473 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
474 start with one land cell in the middle, then go into cycle of repeatedly
475 selecting a random sea cell and transforming it into land if it is neighbor
476 to land. The cycle ends when a land cell is due to be created at the map's
477 border. Then put some trees on the map (TODO: more precise algorithm desc).
479 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
481 def is_neighbor(coordinates, type):
484 length = world_db["MAP_LENGTH"]
486 diag_west = x + (ind > 0)
487 diag_east = x + (ind < (length - 1))
488 pos = (y * length) + x
489 if (y > 0 and diag_east
490 and type == chr(world_db["MAP"][pos - length + ind])) \
492 and type == chr(world_db["MAP"][pos + 1])) \
493 or (y < (length - 1) and diag_east
494 and type == chr(world_db["MAP"][pos + length + ind])) \
495 or (y > 0 and diag_west
496 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
498 and type == chr(world_db["MAP"][pos - 1])) \
499 or (y < (length - 1) and diag_west
500 and type == chr(world_db["MAP"][pos + length - (not ind)])):
504 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
505 length = world_db["MAP_LENGTH"]
506 add_half_width = (not (length % 2)) * int(length / 2)
507 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
509 y = rand.next() % length
510 x = rand.next() % length
511 pos = (y * length) + x
512 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
513 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
515 world_db["MAP"][pos] = ord(".")
516 n_trees = int((length ** 2) / 16)
518 while (i_trees <= n_trees):
519 single_allowed = rand.next() % 32
520 y = rand.next() % length
521 x = rand.next() % length
522 pos = (y * length) + x
523 if "." == chr(world_db["MAP"][pos]) \
524 and ((not single_allowed) or is_neighbor((y, x), "X")):
525 world_db["MAP"][pos] = ord("X")
527 # This all-too-precise replica of the original C code misses iter_limit().
528 n_colons = int((length ** 2) / 16) # #
530 while (i_colons <= n_colons): # #
531 single_allowed = rand.next() % 256 # #
532 y = rand.next() % length # #
533 x = rand.next() % length # #
534 pos = (y * length) + x # #
535 if ("." == chr(world_db["MAP"][pos]) # #
536 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
537 world_db["MAP"][pos] = ord(":") # #
539 altar_placed = False # #
540 while not altar_placed: # #
541 y = rand.next() % length # #
542 x = rand.next() % length # #
543 pos = (y * length) + x # #
544 if (("." == chr(world_db["MAP"][pos] # #
545 or ":" == chr(world_db["MAP"][pos]))
546 and not is_neighbor((y, x), "X"))): # #
547 world_db["MAP"][pos] = ord("_") # #
548 world_db["altar"] = (y, x) # #
549 altar_placed = True # #
552 def update_map_memory(t, age_map=True):
553 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
555 def age_some_memdepthmap_on_nonfov_cells():
556 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
560 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
561 # if not ord_v == t["fovmap"][pos]
562 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
563 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
564 # if not rand.next() % (2 **
565 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
566 # t["T_MEMDEPTHMAP"][pos] += 1
567 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
568 fovmap = c_pointer_to_bytearray(t["fovmap"])
569 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
571 if not t["T_MEMMAP"]:
572 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
573 if not t["T_MEMDEPTHMAP"]:
574 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
578 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
579 if ord_v == t["fovmap"][pos]]:
580 t["T_MEMDEPTHMAP"][pos] = ord_0
581 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
583 age_some_memdepthmap_on_nonfov_cells()
584 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
585 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
587 for id in [id for id in world_db["Things"]
588 if not world_db["Things"][id]["carried"]]:
589 type = world_db["Things"][id]["T_TYPE"]
590 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
591 y = world_db["Things"][id]["T_POSY"]
592 x = world_db["Things"][id]["T_POSX"]
593 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
594 t["T_MEMTHING"].append((type, y, x))
597 def set_world_inactive():
598 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
600 if os.access(io_db["path_worldstate"], os.F_OK):
601 os.remove(io_db["path_worldstate"])
602 world_db["WORLD_ACTIVE"] = 0
605 def integer_test(val_string, min, max=None):
606 """Return val_string if possible integer >= min and <= max, else None."""
608 val = int(val_string)
609 if val < min or (max is not None and val > max):
613 msg = "Ignoring: Please use integer >= " + str(min)
615 msg += " and <= " + str(max)
621 def setter(category, key, min, max=None):
622 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
625 val = integer_test(val_string, min, max)
629 if category == "Thing":
630 id_store = command_tid
631 decorator = test_Thing_id
632 elif category == "ThingType":
633 id_store = command_ttid
634 decorator = test_ThingType_id
635 elif category == "ThingAction":
636 id_store = command_taid
637 decorator = test_ThingAction_id
641 val = integer_test(val_string, min, max)
643 world_db[category + "s"][id_store.id][key] = val
647 def build_fov_map(t):
648 """Build Thing's FOV map."""
649 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
650 fovmap = c_pointer_to_bytearray(t["fovmap"])
651 map = c_pointer_to_bytearray(world_db["MAP"])
652 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
653 raise RuntimeError("Malloc error in build_fov_Map().")
657 """Send quick usage info to log."""
658 log("Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.")
659 log("Use 'p' to pick up objects, and 'D' to drop them.")
660 log("Some objects can be used (such as: eaten) by 'u' if they are in "
661 + "your inventory. Use 'Up'/'Down' to navigate the inventory.")
662 log("Use 'l' to toggle 'look' mode (move an exploration cursor instead of "
663 + "the player over the map).")
664 log("Use 'PgUp'/PgDn' to scroll the 'Things here' window.")
665 log("See README file for more details.")
668 def decrement_lifepoints(t):
669 """Decrement t's lifepoints by 1, and if to zero, corpse it.
671 If t is the player avatar, only blank its fovmap, so that the client may
672 still display memory data. On non-player things, erase fovmap and memory.
673 Dying actors drop all their things.
675 # 7DRL: Also decrements God's mood; deaths heavily so.
676 # 7DRL: Return 1 if death, else 0.
677 t["T_LIFEPOINTS"] -= 1
678 world_db["GOD_MOOD"] -= 1 # #
679 if 0 == t["T_LIFEPOINTS"]:
680 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
681 world_db["GOD_MOOD"] -= sadness # #
682 for id in t["T_CARRIES"]:
683 t["T_CARRIES"].remove(id)
684 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
685 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
686 world_db["Things"][id]["carried"] = False
687 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
688 if world_db["Things"][0] == t:
689 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
691 log("See README on how to start over.")
694 t["T_MEMMAP"] = False
695 t["T_MEMDEPTHMAP"] = False
701 def add_gods_favor(i): # #
702 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
703 def favor_multiplier(i):
705 threshold = math.e * x
706 mood = world_db["GOD_MOOD"]
709 i = i * math.log(mood / x)
710 elif -mood > threshold:
711 i = i / math.log(-mood / x)
713 if -mood > threshold:
714 i = i * math.log(-mood / x)
716 i = i / math.log(mood / x)
718 world_db["GOD_FAVOR"] += favor_multiplier(i)
721 def mv_yx_in_dir_legal(dir, y, x):
722 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
723 dir_c = dir.encode("ascii")[0]
724 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
726 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
727 return (test, libpr.result_y(), libpr.result_x())
730 def enter_altar(): # #
731 """What happens when the player enters the altar."""
732 if world_db["FAVOR_STAGE"] > 9000:
733 log("You step on a soul-less slab of stone.")
735 log("YOU ENTER SACRED GROUND.")
736 if world_db["FAVOR_STAGE"] == 0:
737 world_db["FAVOR_STAGE"] = 1
738 log("The Island God speaks to you: \"I don't trust you. You intrude "
739 + "on the island's affairs. I think you're a nuisance at best, "
740 + "and a danger to my children at worst. I will give you a "
741 + "chance to lighten my mood, however: For a while now, I've "
742 + "been trying to spread the plant "
743 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"] + " (\""
744 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
745 + "\"). I have not been very successful so far. Maybe you can "
746 + "make yourself useful there. I will count each further "
747 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
748 + " that grows to your favor.\"")
749 elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
750 world_db["FAVOR_STAGE"] = 2
751 log("The Island God speaks to you: \"You could have done worse so "
752 + "far. Maybe you are not the worst to happen to this island "
753 + "since the metal birds threw the great lightning ball. Maybe "
754 + "you can help me spread another plant. It multiplies faster, "
755 + "and it is highly nutritious: "
756 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"] + " (\""
757 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_SYMBOL"]
758 + "\"). It is new. I give you the only example. Be very careful "
759 + "with it! I also give you another tool that may be helpful.\"")
760 id = id_setter(-1, "Things")
761 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
763 id = id_setter(-1, "Things")
764 world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
766 elif world_db["FAVOR_STAGE"] == 2 and \
767 0 == len([id for id in world_db["Things"]
768 if world_db["Things"][id]["T_TYPE"]
769 == world_db["PLANT_1"]]):
770 log("The Island God speaks to you: \"I am greatly disappointed that "
772 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
773 + " this island had. Here is another one. It cost me great work. "
774 + "Be more careful this time.\"")
775 id = id_setter(-1, "Things")
776 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
779 elif world_db["GOD_FAVOR"] > 9000:
780 world_db["FAVOR_STAGE"] = 9001
781 log("The Island God speaks to you: \"You have proven yourself worthy"
782 + " of my respect. You were a good citizen to the island, and "
783 + "sometimes a better steward to its inhabitants than me. The "
784 + "island shall miss you when you leave. But you have earned "
785 + "the right to do so. Take this "
786 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
787 + " and USE it when you please. It will take you to where you "
788 + "came from. (But do feel free to stay here as long as you "
790 id = id_setter(-1, "Things")
791 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
796 """Make t do nothing (but loudly, if player avatar)."""
797 if t == world_db["Things"][0]:
802 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
803 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
804 # 7DRL: Player entering the altar triggers enter_altar().
805 # 7DRL: Player with axe chops down trees.
807 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
808 t["T_POSY"], t["T_POSX"])
809 if 1 == move_result[0]:
810 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
811 hitted = [id for id in world_db["Things"]
812 if world_db["Things"][id] != t
813 if world_db["Things"][id]["T_LIFEPOINTS"]
814 if world_db["Things"][id]["T_POSY"] == move_result[1]
815 if world_db["Things"][id]["T_POSX"] == move_result[2]]
818 if t == world_db["Things"][0]:
819 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
820 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
821 log("You wound " + hitted_name + ".")
822 add_gods_favor(-1) # #
824 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
825 log(hitter_name +" wounds you.")
826 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
827 if test and t == world_db["Things"][0]: # #
828 add_gods_favor(-test) # #
830 if (ord("X") == world_db["MAP"][pos] # #
831 or ord("|") == world_db["MAP"][pos]): # #
832 carries_axe = False # #
833 for id in t["T_CARRIES"]: # #
834 type = world_db["Things"][id]["T_TYPE"] # #
835 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # #
836 carries_axe = True # #
839 axe_name = world_db["ThingTypes"][type]["TT_NAME"] # #
840 if t == world_db["Things"][0]: # #
841 log("With your " + axe_name + ", you chop!\n") # #
842 if ord("X") == world_db["MAP"][pos]: # #
843 add_gods_favor(-1) # #
844 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
845 case_X = world_db["MAP"][pos] == ord("X") # #
846 if (chop_power > 0 # #
848 0 == int(rand.next() / chop_power)) # #
849 or (not case_X and # #
850 0 == int(rand.next() / (3 * chop_power))))): # #
851 if t == world_db["Things"][0]: # #
852 log("You chop it down.") # #
853 if world_db["MAP"][pos] == ord("X"): # #
854 add_gods_favor(-10) # #
855 world_db["MAP"][pos] = ord(".") # #
856 i = 3 if case_X else 1 # #
857 for i in range(i): # #
858 id = id_setter(-1, "Things") # #
859 world_db["Things"][id] = \
860 new_Thing(world_db["LUMBER"], # #
861 (move_result[1], move_result[2])) # #
864 passable = ("." == chr(world_db["MAP"][pos]) or
865 ":" == chr(world_db["MAP"][pos]) or # #
866 "_" == chr(world_db["MAP"][pos])) # #
867 dir = [dir for dir in directions_db
868 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
870 t["T_POSY"] = move_result[1]
871 t["T_POSX"] = move_result[2]
872 for id in t["T_CARRIES"]:
873 world_db["Things"][id]["T_POSY"] = move_result[1]
874 world_db["Things"][id]["T_POSX"] = move_result[2]
876 if t == world_db["Things"][0]:
877 log("You move " + dir + ".")
878 if (move_result[1] == world_db["altar"][0] and # #
879 move_result[2] == world_db["altar"][1]): # #
881 elif t == world_db["Things"][0]:
882 log("You fail to move " + dir + ".")
885 def actor_pick_up(t):
886 """Make t pick up (topmost?) Thing from ground into inventory.
888 Define topmostness by how low the thing's type ID is.
890 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
891 # 7DRL: Only player picks up non-food.
892 used_slots = len(t["T_CARRIES"]) # #
893 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
894 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
895 if not world_db["Things"][id]["carried"]
896 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
897 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
901 tid = world_db["Things"][iid]["T_TYPE"]
902 if lowest_tid == -1 or tid < lowest_tid:
903 if (t != world_db["Things"][0] and # #
904 world_db["ThingTypes"][tid]["TT_TOOL"] != "food"):
908 world_db["Things"][id]["carried"] = True
909 type = world_db["Things"][id]["T_TYPE"] # #
910 if (t != world_db["Things"][0] # #
911 and world_db["Things"][id]["T_PLAYERDROP"] # #
912 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # #
913 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # #
914 add_gods_favor(score) # #
915 world_db["Things"][id]["T_PLAYERDROP"] = 0 # #
916 t["T_CARRIES"].append(id)
917 if t == world_db["Things"][0]:
918 log("You pick up an object.")
919 elif t == world_db["Things"][0]:
920 log("You try to pick up an object, but there is none.")
921 elif t == world_db["Things"][0]: # #
922 log("Can't pick up object: No storage room to carry more.") # #
926 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
927 # TODO: Handle case where T_ARGUMENT matches nothing.
928 if len(t["T_CARRIES"]):
929 id = t["T_CARRIES"][t["T_ARGUMENT"]]
930 t["T_CARRIES"].remove(id)
931 world_db["Things"][id]["carried"] = False
932 if t == world_db["Things"][0]:
933 log("You drop an object.")
934 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
935 elif t == world_db["Things"][0]:
936 log("You try to drop an object, but you own none.")
940 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
941 # TODO: Handle case where T_ARGUMENT matches nothing.
942 # 7DLR: Handle SLIPPERS-type Thing use.
943 if len(t["T_CARRIES"]):
944 id = t["T_CARRIES"][t["T_ARGUMENT"]]
945 type = world_db["Things"][id]["T_TYPE"]
946 if type == world_db["SLIPPERS"]: # #
947 if t == world_db["Things"][0]: # #
948 log("You use the " + world_db["ThingTypes"][type]["TT_NAME"] # #
949 + ". It glows in wondrous colors, and emits a sound as " # #
950 + "if from a dying cat. The Island God laughs.\n") # #
951 t["T_LIFEPOINTS"] = 1 # #
952 decrement_lifepoints(t) # #
953 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # #
954 and t == world_db["Things"][0]): # #
955 log("To use this item for chopping, move towards a tree while "
956 + "carrying it in your inventory.") # #
957 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"): # #
958 pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
959 if (world_db["MAP"][pos] == ord("X") # #
960 or world_db["MAP"][pos] == ord("|")): # #
961 log("Can't build when standing on barrier.") # #
963 for id in [id for id in world_db["Things"]
964 if not world_db["Things"][id] == t
965 if not world_db["Things"][id]["carried"]
966 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
967 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
968 log("Can't build when standing objects.") # #
970 for id in t["T_CARRIES"]: # #
971 type_tool = world_db["Things"][id]["T_TYPE"] # #
972 if (world_db["ThingTypes"][type_tool]["TT_TOOL"] # #
976 for id in t["T_CARRIES"]: # #
977 type_material = world_db["Things"][id]["T_TYPE"] # #
978 if (world_db["ThingTypes"][type_material]["TT_TOOL"] # #
982 if wood_id != None: # #
983 t["T_CARRIES"].remove(wood_id) # #
984 del world_db["Things"][wood_id] # #
985 world_db["MAP"][pos] = ord("|") # #
987 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
988 + " you build a wooden barrier from your " # #
989 + world_db["ThingTypes"][type_material]["TT_NAME"] # #
992 log("You can't use a " # #
993 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
994 + " without some wood in your inventory.") # #
995 elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
996 t["T_CARRIES"].remove(id)
997 del world_db["Things"][id]
998 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
999 if t == world_db["Things"][0]:
1000 log("You consume this object.")
1001 elif t == world_db["Things"][0]:
1002 log("You try to use this object, but fail.")
1003 elif t == world_db["Things"][0]:
1004 log("You try to use an object, but you own none.")
1007 def thingproliferation(t, prol_map):
1008 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1010 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1011 marked "." in prol_map. If there are several map cell candidates, one is
1014 # 7DRL: success increments God's mood
1015 # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1016 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1017 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1019 for dir in [directions_db[key] for key in directions_db]:
1020 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1021 pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1022 if mv_result[0] and \
1023 (ord(":") == prol_map[pos] # #
1024 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1025 and ord(".") == prol_map[pos])):
1026 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1027 # * world_db["MAP_LENGTH"]
1029 candidates.append((mv_result[1], mv_result[2]))
1031 i = rand.next() % len(candidates)
1032 id = id_setter(-1, "Things")
1033 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1034 world_db["Things"][id] = newT
1035 animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1037 world_db["GOD_MOOD"] += animacy # #
1039 world_db["GOD_MOOD"] += 1 # #
1040 if (world_db["FAVOR_STAGE"] > 0 # #
1041 and t["T_TYPE"] == world_db["PLANT_0"]): # #
1042 world_db["GOD_FAVOR"] += 5 # #
1043 elif t["T_TYPE"] == world_db["PLANT_1"]: # #
1044 world_db["GOD_FAVOR"] += 25 # #
1048 """If t's HP < max, increment them if well-nourished, maybe waiting."""
1049 # 7DRL: Successful heals increment God's mood.
1050 if t["T_LIFEPOINTS"] < \
1051 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1052 wait_id = [id for id in world_db["ThingActions"]
1053 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1054 wait_divider = 8 if t["T_COMMAND"] == wait_id else 1
1055 testval = int(abs(t["T_SATIATION"]) / wait_divider)
1056 if (testval <= 1 or 1 == (rand.next() % testval)):
1057 t["T_LIFEPOINTS"] += 1
1058 if t != world_db["Things"][0]: # #
1059 world_db["GOD_MOOD"] += 1 # #
1060 if t == world_db["Things"][0]:
1064 def hunger_per_turn(type_id):
1065 """The amount of satiation score lost per turn for things of given type."""
1066 return int(math.sqrt(world_db["ThingTypes"][type_id]["TT_LIFEPOINTS"]))
1070 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1071 if t["T_SATIATION"] > -32768:
1072 #max_hp = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]
1073 t["T_SATIATION"] -= hunger_per_turn(t["T_TYPE"]) # int(math.sqrt(max_hp))
1074 if 0 != t["T_SATIATION"] and 0 == int(rand.next() / abs(t["T_SATIATION"])):
1075 if t == world_db["Things"][0]:
1076 if t["T_SATIATION"] < 0:
1077 log("You suffer from hunger.")
1079 log("You suffer from over-eating.")
1080 decrement_lifepoints(t)
1083 def get_dir_to_target(t, filter):
1084 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1086 The path-wise nearest target is chosen, via the shortest available path.
1087 Target must not be t. On succcess, return positive value, else False.
1089 "a": Thing in FOV is below a certain distance, animate, but of ThingType
1090 that is not t's, and starts out weaker than t is; build path as
1091 avoiding things of t's ThingType
1092 "f": neighbor cell (not inhabited by any animate Thing) further away from
1093 animate Thing not further than x steps away and in FOV and of a
1094 ThingType that is not t's, and starts out stronger or as strong as t
1095 is currently; or (cornered), if no such flight cell, but Thing of
1096 above criteria is too near,1 a cell closer to it, or, if less near,
1098 "c": Thing in memorized map is consumable
1099 "s": memory map cell with greatest-reachable degree of unexploredness
1102 def zero_score_map_where_char_on_memdepthmap(c):
1103 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1104 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1105 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1106 # set_map_score(i, 0)
1107 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1108 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1109 raise RuntimeError("No score map allocated for "
1110 "zero_score_map_where_char_on_memdepthmap().")
1112 def set_map_score(pos, score):
1113 test = libpr.set_map_score(pos, score)
1115 raise RuntimeError("No score map allocated for set_map_score().")
1117 def get_map_score(pos):
1118 result = libpr.get_map_score(pos)
1120 raise RuntimeError("No score map allocated for get_map_score().")
1124 if t["fovmap"] and ("a" == filter or "f" == filter):
1125 for id in world_db["Things"]:
1126 Thing = world_db["Things"][id]
1127 if Thing != t and Thing["T_LIFEPOINTS"] and \
1128 t["T_TYPE"] != Thing["T_TYPE"] and \
1129 'v' == chr(t["fovmap"][(Thing["T_POSY"]
1130 * world_db["MAP_LENGTH"])
1131 + Thing["T_POSX"]]):
1132 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1133 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1134 t["T_LIFEPOINTS"]) \
1135 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1138 elif t["T_MEMMAP"] and "c" == filter:
1139 for mt in t["T_MEMTHING"]:
1140 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1142 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1146 def set_cells_passable_on_memmap_to_65534_on_scoremap():
1147 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1148 # ord_dot = ord(".")
1149 # memmap = t["T_MEMMAP"]
1150 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1151 # if ord_dot == memmap[i]]:
1152 # set_map_score(i, 65534) # i.e. 65535-1
1153 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1154 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1155 raise RuntimeError("No score map allocated for "
1156 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1158 def init_score_map():
1159 test = libpr.init_score_map()
1161 raise RuntimeError("Malloc error in init_score_map().")
1163 ord_blank = ord(" ")
1164 set_cells_passable_on_memmap_to_65534_on_scoremap()
1166 for id in world_db["Things"]:
1167 Thing = world_db["Things"][id]
1168 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1170 if t != Thing and Thing["T_LIFEPOINTS"] and \
1171 t["T_TYPE"] != Thing["T_TYPE"] and \
1172 ord_v == t["fovmap"][pos] and \
1173 t["T_LIFEPOINTS"] > \
1174 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1175 set_map_score(pos, 0)
1176 elif t["T_TYPE"] == Thing["T_TYPE"]:
1177 set_map_score(pos, 65535)
1179 for id in [id for id in world_db["Things"]
1180 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1181 Thing = world_db["Things"][id]
1182 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1184 if t["T_TYPE"] != Thing["T_TYPE"] and \
1185 ord_v == t["fovmap"][pos] and \
1186 t["T_LIFEPOINTS"] <= \
1187 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1188 set_map_score(pos, 0)
1190 for mt in [mt for mt in t["T_MEMTHING"]
1191 if ord_blank != t["T_MEMMAP"][mt[1]
1192 * world_db["MAP_LENGTH"]
1194 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1195 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1197 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1199 def rand_target_dir(neighbors, cmp, dirs):
1202 for i in range(len(dirs)):
1203 if cmp == neighbors[i]:
1204 candidates.append(dirs[i])
1206 return candidates[rand.next() % n_candidates] if n_candidates else 0
1208 def get_neighbor_scores(dirs, eye_pos):
1210 if libpr.ready_neighbor_scores(eye_pos):
1211 raise RuntimeError("No score map allocated for " +
1212 "ready_neighbor_scores.()")
1213 for i in range(len(dirs)):
1214 scores.append(libpr.get_neighbor_score(i))
1217 def get_dir_from_neighbors():
1218 dir_to_target = False
1220 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1221 neighbors = get_neighbor_scores(dirs, eye_pos)
1223 inhabited = [world_db["Things"][id]["T_POSY"]
1224 * world_db["MAP_LENGTH"]
1225 + world_db["Things"][id]["T_POSX"]
1226 for id in world_db["Things"]
1227 if world_db["Things"][id]["T_LIFEPOINTS"]]
1228 for i in range(len(dirs)):
1229 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1230 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1232 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1233 neighbors[i] = 65535
1235 minmax_start = 0 if "f" == filter else 65535 - 1
1236 minmax_neighbor = minmax_start
1237 for i in range(len(dirs)):
1238 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1239 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1240 or ("f" != filter and minmax_neighbor > neighbors[i]):
1241 minmax_neighbor = neighbors[i]
1242 if minmax_neighbor != minmax_start:
1243 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1245 if not dir_to_target:
1246 if 1 == get_map_score(eye_pos):
1247 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1248 elif 3 >= get_map_score(eye_pos):
1249 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1251 world_db["ThingActions"][id]["TA_NAME"]
1254 elif dir_to_target and 3 < get_map_score(eye_pos):
1256 elif "a" == filter and 10 <= get_map_score(eye_pos):
1258 return dir_to_target
1260 dir_to_target = False
1262 run_i = 9 + 1 if "s" == filter else 1
1263 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1266 mem_depth_c = b'9' if b' ' == mem_depth_c \
1267 else bytes([mem_depth_c[0] - 1])
1268 if libpr.dijkstra_map():
1269 raise RuntimeError("No score map allocated for dijkstra_map().")
1270 dir_to_target = get_dir_from_neighbors()
1271 libpr.free_score_map()
1272 if dir_to_target and str == type(dir_to_target):
1273 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1274 if world_db["ThingActions"][id]["TA_NAME"]
1276 t["T_ARGUMENT"] = ord(dir_to_target)
1277 return dir_to_target
1280 def standing_on_food(t):
1281 """Return True/False whether t is standing on a consumable."""
1282 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1283 if not world_db["Things"][id]["carried"]
1284 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1285 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1286 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1287 ["TT_TOOL"] == "food"]:
1292 def get_inventory_slot_to_consume(t):
1293 """Return invent. slot of healthiest consumable(if any healthy),else -1."""
1297 hunger_u = hunger_per_turn(t["T_TYPE"])
1298 type = [id for id in world_db["ThingActions"]
1299 if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
1300 consume_hungering = world_db["ThingActions"][type]["TA_EFFORT"] * hunger_u
1301 for id in t["T_CARRIES"]:
1302 type = world_db["Things"][id]["T_TYPE"]
1303 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1304 and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
1305 nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1306 tmp_cmp = abs(t["T_SATIATION"] + nutvalue - consume_hungering)
1307 if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1308 or tmp_cmp < cmp_food:
1316 """Determine next command/argment for actor t via AI algorithms.
1318 AI will look for, and move towards, enemies (animate Things not of their
1319 own ThingType); if they see none, they will consume consumables in their
1320 inventory; if there are none, they will pick up what they stand on if they
1321 stand on consumables; if they stand on none, they will move towards the
1322 next consumable they see or remember on the map; if they see or remember
1323 none, they will explore parts of the map unseen since ever or for at least
1324 one turn; if there is nothing to explore, they will simply wait.
1326 # 7DRL add: Don't pick up or search things when inventory is full.
1327 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1328 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1329 if not get_dir_to_target(t, "f"):
1330 sel = get_inventory_slot_to_consume(t)
1332 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1333 if world_db["ThingActions"][id]["TA_NAME"]
1335 t["T_ARGUMENT"] = sel
1336 elif standing_on_food(t) \
1337 and (len(t["T_CARRIES"]) < # #
1338 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1339 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1340 if world_db["ThingActions"][id]["TA_NAME"]
1343 (len(t["T_CARRIES"]) < # #
1344 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1345 and get_dir_to_target(t, "c"))) and \
1346 (not get_dir_to_target(t, "a")):
1347 get_dir_to_target(t, "s")
1351 """Run game world and its inhabitants until new player input expected."""
1353 whilebreaker = False
1354 while world_db["Things"][0]["T_LIFEPOINTS"]:
1355 proliferable_map = world_db["MAP"][:]
1356 for id in [id for id in world_db["Things"]
1357 if not world_db["Things"][id]["carried"]]:
1358 y = world_db["Things"][id]["T_POSY"]
1359 x = world_db["Things"][id]["T_POSX"]
1360 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1361 for id in [id for id in world_db["Things"]]: # Only what's from start!
1362 if not id in world_db["Things"] or \
1363 world_db["Things"][id]["carried"]: # May have been consumed or
1364 continue # picked up during turn …
1365 Thing = world_db["Things"][id]
1366 if Thing["T_LIFEPOINTS"]:
1367 if not Thing["T_COMMAND"]:
1368 update_map_memory(Thing)
1375 if Thing["T_LIFEPOINTS"]:
1376 Thing["T_PROGRESS"] += 1
1377 taid = [a for a in world_db["ThingActions"]
1378 if a == Thing["T_COMMAND"]][0]
1379 ThingAction = world_db["ThingActions"][taid]
1380 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1381 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1382 Thing["T_COMMAND"] = 0
1383 Thing["T_PROGRESS"] = 0
1384 thingproliferation(Thing, proliferable_map)
1387 world_db["TURN"] += 1
1390 def new_Thing(type, pos=(0, 0)):
1391 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1393 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1398 "T_PLAYERDROP": 0, # #
1406 "T_MEMDEPTHMAP": False,
1409 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1410 build_fov_map(thing)
1414 def id_setter(id, category, id_store=False, start_at_1=False):
1415 """Set ID of object of category to manipulate ID unused? Create new one.
1417 The ID is stored as id_store.id (if id_store is set). If the integer of the
1418 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1419 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1420 always returned when no new object is created, otherwise the new object's
1423 min = 0 if start_at_1 else -1
1425 id = integer_test(id, min)
1427 if id in world_db[category]:
1432 if (start_at_1 and 0 == id) \
1433 or ((not start_at_1) and (id < 0)):
1434 id = 0 if start_at_1 else -1
1437 if id not in world_db[category]:
1445 """Send PONG line to server output file."""
1446 strong_write(io_db["file_out"], "PONG\n")
1450 """Abort server process."""
1451 if None == opts.replay:
1452 if world_db["WORLD_ACTIVE"]:
1454 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1455 raise SystemExit("received QUIT command")
1458 def command_thingshere(str_y, str_x):
1459 """Write to out file list of Things known to player at coordinate y, x."""
1460 # 7DRL: terrain, too
1461 if world_db["WORLD_ACTIVE"]:
1462 y = integer_test(str_y, 0, 255)
1463 x = integer_test(str_x, 0, 255)
1464 length = world_db["MAP_LENGTH"]
1465 if None != y and None != x and y < length and x < length:
1466 pos = (y * world_db["MAP_LENGTH"]) + x
1467 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1468 pos = y * world_db["MAP_LENGTH"] + x; # #
1469 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1470 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1471 for id in world_db["Things"]
1472 if not world_db["Things"][id]["carried"]
1473 if world_db["Things"][id]["T_TYPE"] == tid
1474 if y == world_db["Things"][id]["T_POSY"]
1475 if x == world_db["Things"][id]["T_POSX"]]:
1476 type = world_db["Things"][id]["T_TYPE"]
1477 name = world_db["ThingTypes"][type]["TT_NAME"]
1478 strong_write(io_db["file_out"], name + "\n")
1480 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1481 for mt in world_db["Things"][0]["T_MEMTHING"]
1482 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1483 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1484 strong_write(io_db["file_out"], name + "\n")
1485 if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"): # #
1486 name = "(terrain: SEA)" # #
1487 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."): # #
1488 name = "(terrain: EARTH)" # #
1489 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"): # #
1490 name = "(terrain: SOIL)" # #
1491 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"): # #
1492 name = "(terrain: TREE)" # #
1493 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"): # #
1494 name = "(terrain: WALL)" # #
1495 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"): # #
1496 name = "(terrain: ALTAR)" # #
1499 strong_write(io_db["file_out"], name + "\n") # #
1500 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1502 print("Ignoring: Invalid map coordinates.")
1504 print("Ignoring: Command only works on existing worlds.")
1507 def play_commander(action, args=False):
1508 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1510 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1514 id = [x for x in world_db["ThingActions"]
1515 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1516 world_db["Things"][0]["T_COMMAND"] = id
1519 def set_command_and_argument_int(str_arg):
1520 val = integer_test(str_arg, 0, 255)
1522 world_db["Things"][0]["T_ARGUMENT"] = val
1525 def set_command_and_argument_movestring(str_arg):
1526 if str_arg in directions_db:
1527 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1530 print("Ignoring: Argument must be valid direction string.")
1532 if action == "move":
1533 return set_command_and_argument_movestring
1535 return set_command_and_argument_int
1540 def command_seedrandomness(seed_string):
1541 """Set rand seed to int(seed_string)."""
1542 val = integer_test(seed_string, 0, 4294967295)
1547 def command_makeworld(seed_string):
1548 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1550 Seed rand with seed. Do more only with a "wait" ThingAction and
1551 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1552 world_db["Things"] emptied, call make_map() and set
1553 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1554 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1555 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1556 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1560 # def free_pos(plant=False):
1561 def free_pos(plant=False): # #
1564 err = "Space to put thing on too hard to find. Map too small?"
1566 y = rand.next() % world_db["MAP_LENGTH"]
1567 x = rand.next() % world_db["MAP_LENGTH"]
1568 pos = y * world_db["MAP_LENGTH"] + x;
1570 and "." == chr(world_db["MAP"][pos])) \
1571 or ":" == chr(world_db["MAP"][pos]): # #
1575 raise SystemExit(err)
1576 # Replica of C code, wrongly ignores animatedness of new Thing.
1577 pos_clear = (0 == len([id for id in world_db["Things"]
1578 if world_db["Things"][id]["T_LIFEPOINTS"]
1579 if world_db["Things"][id]["T_POSY"] == y
1580 if world_db["Things"][id]["T_POSX"] == x]))
1585 val = integer_test(seed_string, 0, 4294967295)
1589 player_will_be_generated = False
1590 playertype = world_db["PLAYER_TYPE"]
1591 for ThingType in world_db["ThingTypes"]:
1592 if playertype == ThingType:
1593 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1594 player_will_be_generated = True
1596 if not player_will_be_generated:
1597 print("Ignoring: No player type with start number >0 defined.")
1600 for ThingAction in world_db["ThingActions"]:
1601 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1604 print("Ignoring: No thing action with name 'wait' defined.")
1606 for name in specials: # #
1607 if world_db[name] not in world_db["ThingTypes"]: # #
1608 print("Ignoring: No valid " + name + " set.") # #
1610 world_db["Things"] = {}
1612 world_db["WORLD_ACTIVE"] = 1
1613 world_db["TURN"] = 1
1614 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1615 id = id_setter(-1, "Things")
1616 world_db["Things"][id] = new_Thing(playertype, free_pos())
1617 if not world_db["Things"][0]["fovmap"]:
1618 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1619 world_db["Things"][0]["fovmap"] = empty_fovmap
1620 update_map_memory(world_db["Things"][0])
1621 for type in world_db["ThingTypes"]:
1622 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1623 if type != playertype:
1624 id = id_setter(-1, "Things")
1625 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1626 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1627 strong_write(io_db["file_out"], "NEW_WORLD\n")
1631 def command_maplength(maplength_string):
1632 """Redefine map length. Invalidate map, therefore lose all things on it."""
1633 val = integer_test(maplength_string, 1, 256)
1635 world_db["MAP_LENGTH"] = val
1636 world_db["MAP"] = False
1637 set_world_inactive()
1638 world_db["Things"] = {}
1639 libpr.set_maplength(val)
1642 def command_worldactive(worldactive_string):
1643 """Toggle world_db["WORLD_ACTIVE"] if possible.
1645 An active world can always be set inactive. An inactive world can only be
1646 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1647 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1648 Also call log_help().
1650 # 7DRL: altar must be on map, and specials must be set for active world.
1651 val = integer_test(worldactive_string, 0, 1)
1653 if 0 != world_db["WORLD_ACTIVE"]:
1655 set_world_inactive()
1657 print("World already active.")
1658 elif 0 == world_db["WORLD_ACTIVE"]:
1660 for ThingAction in world_db["ThingActions"]:
1661 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1664 player_exists = False
1665 for Thing in world_db["Things"]:
1667 player_exists = True
1669 specials_set = True # #
1670 for name in specials: # #
1671 if world_db[name] not in world_db["ThingTypes"]: # #
1672 specials_set = False # #
1673 altar_found = False # #
1674 if world_db["MAP"]: # #
1675 pos = world_db["MAP"].find(b'_') # #
1677 y = int(pos / world_db["MAP_LENGTH"]) # #
1678 x = pos % world_db["MAP_LENGTH"] # #
1679 world_db["altar"] = (y, x) # #
1680 altar_found = True # #
1681 if wait_exists and player_exists and world_db["MAP"] \
1682 and specials_set: # #
1683 for id in world_db["Things"]:
1684 if world_db["Things"][id]["T_LIFEPOINTS"]:
1685 build_fov_map(world_db["Things"][id])
1687 update_map_memory(world_db["Things"][id], False)
1688 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1689 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1690 world_db["Things"][0]["fovmap"] = empty_fovmap
1691 world_db["WORLD_ACTIVE"] = 1
1694 print("Ignoring: Not all conditions for world activation met.")
1697 def specialtypesetter(name): # #
1698 """Setter world_db[name], deactivating world if set int no ThingType."""
1699 def helper(str_int):
1700 val = integer_test(str_int, 0)
1702 world_db[name] = val
1703 if world_db["WORLD_ACTIVE"] \
1704 and world_db[name] not in world_db["ThingTypes"]:
1705 world_db["WORLD_ACTIVE"] = 0
1706 print(name + " fits no known ThingType, deactivating world.")
1710 def test_for_id_maker(object, category):
1711 """Return decorator testing for object having "id" attribute."""
1714 if hasattr(object, "id"):
1717 print("Ignoring: No " + category +
1718 " defined to manipulate yet.")
1723 def command_tid(id_string):
1724 """Set ID of Thing to manipulate. ID unused? Create new one.
1726 Default new Thing's type to the first available ThingType, others: zero.
1728 id = id_setter(id_string, "Things", command_tid)
1730 if world_db["ThingTypes"] == {}:
1731 print("Ignoring: No ThingType to settle new Thing in.")
1733 type = list(world_db["ThingTypes"].keys())[0]
1734 world_db["Things"][id] = new_Thing(type)
1737 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1741 def command_tcommand(str_int):
1742 """Set T_COMMAND of selected Thing."""
1743 val = integer_test(str_int, 0)
1745 if 0 == val or val in world_db["ThingActions"]:
1746 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1748 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1752 def command_ttype(str_int):
1753 """Set T_TYPE of selected Thing."""
1754 val = integer_test(str_int, 0)
1756 if val in world_db["ThingTypes"]:
1757 world_db["Things"][command_tid.id]["T_TYPE"] = val
1759 print("Ignoring: ThingType ID belongs to no known ThingType.")
1763 def command_tcarries(str_int):
1764 """Append int(str_int) to T_CARRIES of selected Thing.
1766 The ID int(str_int) must not be of the selected Thing, and must belong to a
1767 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1769 val = integer_test(str_int, 0)
1771 if val == command_tid.id:
1772 print("Ignoring: Thing cannot carry itself.")
1773 elif val in world_db["Things"] \
1774 and not world_db["Things"][val]["carried"]:
1775 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1776 world_db["Things"][val]["carried"] = True
1778 print("Ignoring: Thing not available for carrying.")
1779 # Note that the whole carrying structure is different from the C version:
1780 # Carried-ness is marked by a "carried" flag, not by Things containing
1781 # Things internally.
1785 def command_tmemthing(str_t, str_y, str_x):
1786 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1788 The type must fit to an existing ThingType, and the position into the map.
1790 type = integer_test(str_t, 0)
1791 posy = integer_test(str_y, 0, 255)
1792 posx = integer_test(str_x, 0, 255)
1793 if None != type and None != posy and None != posx:
1794 if type not in world_db["ThingTypes"] \
1795 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1796 print("Ignoring: Illegal value for thing type or position.")
1798 memthing = (type, posy, posx)
1799 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1802 def setter_map(maptype):
1803 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1805 If no map of maptype exists yet, initialize it with ' ' bytes first.
1808 def valid_map_line(str_int, mapline):
1809 val = integer_test(str_int, 0, 255)
1811 if val >= world_db["MAP_LENGTH"]:
1812 print("Illegal value for map line number.")
1813 elif len(mapline) != world_db["MAP_LENGTH"]:
1814 print("Map line length is unequal map width.")
1819 def nonThingMap_helper(str_int, mapline):
1820 val = valid_map_line(str_int, mapline)
1822 length = world_db["MAP_LENGTH"]
1823 if not world_db["MAP"]:
1824 map = bytearray(b' ' * (length ** 2))
1826 map = world_db["MAP"]
1827 map[val * length:(val * length) + length] = mapline.encode()
1828 if not world_db["MAP"]:
1829 world_db["MAP"] = map
1832 def ThingMap_helper(str_int, mapline):
1833 val = valid_map_line(str_int, mapline)
1835 length = world_db["MAP_LENGTH"]
1836 if not world_db["Things"][command_tid.id][maptype]:
1837 map = bytearray(b' ' * (length ** 2))
1839 map = world_db["Things"][command_tid.id][maptype]
1840 map[val * length:(val * length) + length] = mapline.encode()
1841 if not world_db["Things"][command_tid.id][maptype]:
1842 world_db["Things"][command_tid.id][maptype] = map
1844 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1847 def setter_tpos(axis):
1848 """Generate setter for T_POSX or T_POSY of selected Thing.
1850 If world is active, rebuilds animate things' fovmap, player's memory map.
1853 def helper(str_int):
1854 val = integer_test(str_int, 0, 255)
1856 if val < world_db["MAP_LENGTH"]:
1857 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1858 if world_db["WORLD_ACTIVE"] \
1859 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1860 build_fov_map(world_db["Things"][command_tid.id])
1861 if 0 == command_tid.id:
1862 update_map_memory(world_db["Things"][command_tid.id])
1864 print("Ignoring: Position is outside of map.")
1868 def command_ttid(id_string):
1869 """Set ID of ThingType to manipulate. ID unused? Create new one.
1871 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1874 id = id_setter(id_string, "ThingTypes", command_ttid)
1876 world_db["ThingTypes"][id] = {
1877 "TT_NAME": "(none)",
1880 "TT_PROLIFERATE": 0,
1881 "TT_START_NUMBER": 0,
1882 "TT_STORAGE": 0, # #
1889 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1893 def command_ttname(name):
1894 """Set TT_NAME of selected ThingType."""
1895 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1899 def command_tttool(name):
1900 """Set TT_TOOL of selected ThingType."""
1901 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1905 def command_ttsymbol(char):
1906 """Set TT_SYMBOL of selected ThingType. """
1908 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1910 print("Ignoring: Argument must be single character.")
1914 def command_ttcorpseid(str_int):
1915 """Set TT_CORPSE_ID of selected ThingType."""
1916 val = integer_test(str_int, 0)
1918 if val in world_db["ThingTypes"]:
1919 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1921 print("Ignoring: Corpse ID belongs to no known ThignType.")
1924 def command_taid(id_string):
1925 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1927 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1929 id = id_setter(id_string, "ThingActions", command_taid, True)
1931 world_db["ThingActions"][id] = {
1937 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1940 @test_ThingAction_id
1941 def command_taname(name):
1942 """Set TA_NAME of selected ThingAction.
1944 The name must match a valid thing action function. If after the name
1945 setting no ThingAction with name "wait" remains, call set_world_inactive().
1947 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1948 or name == "pick_up":
1949 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1950 if 1 == world_db["WORLD_ACTIVE"]:
1951 wait_defined = False
1952 for id in world_db["ThingActions"]:
1953 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1956 if not wait_defined:
1957 set_world_inactive()
1959 print("Ignoring: Invalid action name.")
1960 # In contrast to the original,naming won't map a function to a ThingAction.
1964 """Call ai() on player Thing, then turn_over()."""
1965 ai(world_db["Things"][0])
1969 """Commands database.
1971 Map command start tokens to ([0]) number of expected command arguments, ([1])
1972 the command's meta-ness (i.e. is it to be written to the record file, is it to
1973 be ignored in replay mode if read from server input file), and ([2]) a function
1977 "QUIT": (0, True, command_quit),
1978 "PING": (0, True, command_ping),
1979 "THINGS_HERE": (2, True, command_thingshere),
1980 "MAKE_WORLD": (1, False, command_makeworld),
1981 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1982 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1983 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1984 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1985 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1986 "MAP_LENGTH": (1, False, command_maplength),
1987 "WORLD_ACTIVE": (1, False, command_worldactive),
1988 "MAP": (2, False, setter_map("MAP")),
1989 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
1990 "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")), # #
1991 "PLANT_0": (1, False, specialtypesetter("PLANT_0")), # #
1992 "PLANT_1": (1, False, specialtypesetter("PLANT_1")), # #
1993 "LUMBER": (1, False, specialtypesetter("LUMBER")), # #
1994 "TOOL_0": (1, False, specialtypesetter("TOOL_0")), # #
1995 "EMPATHY": (1, False, setter(None, "EMPATHY", 0, 1)), # #
1996 "TA_ID": (1, False, command_taid),
1997 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1998 "TA_NAME": (1, False, command_taname),
1999 "TT_ID": (1, False, command_ttid),
2000 "TT_NAME": (1, False, command_ttname),
2001 "TT_TOOL": (1, False, command_tttool),
2002 "TT_SYMBOL": (1, False, command_ttsymbol),
2003 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
2004 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
2005 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
2007 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2009 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2010 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
2011 "T_ID": (1, False, command_tid),
2012 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2013 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2014 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2015 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2016 "T_COMMAND": (1, False, command_tcommand),
2017 "T_TYPE": (1, False, command_ttype),
2018 "T_CARRIES": (1, False, command_tcarries),
2019 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2020 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2021 "T_MEMTHING": (3, False, command_tmemthing),
2022 "T_POSY": (1, False, setter_tpos("Y")),
2023 "T_POSX": (1, False, setter_tpos("X")),
2024 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
2025 "wait": (0, False, play_commander("wait")),
2026 "move": (1, False, play_commander("move")),
2027 "pick_up": (0, False, play_commander("pick_up")),
2028 "drop": (1, False, play_commander("drop", True)),
2029 "use": (1, False, play_commander("use", True)),
2030 "ai": (0, False, command_ai)
2032 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2035 """World state database. With sane default values. (Randomness is in rand.)"""
2044 "FAVOR_STAGE": 0, # #
2057 """Special type settings."""
2058 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"] # #
2060 """Mapping of direction names to internal direction chars."""
2061 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2062 "west": "s", "north-west": "w", "north-east": "e"}
2064 """File IO database."""
2066 "path_save": "save",
2067 "path_record": "record_save",
2068 "path_worldconf": "confserver/world",
2069 "path_server": "server/",
2070 "path_in": "server/in",
2071 "path_out": "server/out",
2072 "path_worldstate": "server/worldstate",
2073 "tmp_suffix": "_tmp",
2074 "kicked_by_rival": False,
2075 "worldstate_updateable": False
2080 libpr = prep_library()
2081 rand = RandomnessIO()
2082 opts = parse_command_line_arguments()
2084 io_db["path_save"] = opts.savefile
2085 io_db["path_record"] = "record_" + opts.savefile
2088 io_db["verbose"] = True
2089 if None != opts.replay:
2093 except SystemExit as exit:
2094 print("ABORTING: " + exit.args[0])
2096 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")