3 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
4 # or any later version. For details on its copyright, license, and warranties,
5 # see the file NOTICE in the root directory of the PlomRogue source package.
19 """"Interface to libplomrogue's pseudo-randomness generator."""
21 def set_seed(self, seed):
22 libpr.seed_rrand(1, seed)
25 return libpr.seed_rrand(0, 0)
30 seed = property(get_seed, set_seed)
34 """Prepare ctypes library at ./libplomrogue.so"""
35 libpath = ("./libplomrogue.so")
36 if not os.access(libpath, os.F_OK):
37 raise SystemExit("No library " + libpath + ", run ./redo first?")
38 libpr = ctypes.cdll.LoadLibrary(libpath)
39 libpr.seed_rrand.restype = ctypes.c_uint32
43 def c_pointer_to_bytearray(ba):
44 """Return C char * pointer to ba."""
45 type = ctypes.c_char * len(ba)
46 return type.from_buffer(ba)
49 def strong_write(file, string):
50 """Apply write(string), then flush()."""
55 def setup_server_io():
56 """Fill IO files DB with proper file( path)s. Write process IO test string.
58 Ensure IO files directory at server/. Remove any old input file if found.
59 Set up new input file for reading, and new output file for writing. Start
60 output file with process hash line of format PID + " " + floated UNIX time
61 (io_db["teststring"]). Raise SystemExit if file is found at path of either
62 record or save file plus io_db["tmp_suffix"].
64 def detect_atomic_leftover(path, tmp_suffix):
65 path_tmp = path + tmp_suffix
66 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
67 "aborted previous attempt to write '" + path + "'. Aborting " \
68 "until matter is resolved by removing it from its current path."
69 if os.access(path_tmp, os.F_OK):
71 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
72 io_db["save_wait"] = 0
73 io_db["verbose"] = False
74 io_db["record_chunk"] = ""
75 os.makedirs(io_db["path_server"], exist_ok=True)
76 io_db["file_out"] = open(io_db["path_out"], "w")
77 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
78 if os.access(io_db["path_in"], os.F_OK):
79 os.remove(io_db["path_in"])
80 io_db["file_in"] = open(io_db["path_in"], "w")
81 io_db["file_in"].close()
82 io_db["file_in"] = open(io_db["path_in"], "r")
83 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
84 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
87 def cleanup_server_io():
88 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
89 def helper(file_key, path_key):
91 io_db[file_key].close()
92 if not io_db["kicked_by_rival"] \
93 and os.access(io_db[path_key], os.F_OK):
94 os.remove(io_db[path_key])
95 helper("file_in", "path_in")
96 helper("file_out", "path_out")
97 helper("file_worldstate", "path_worldstate")
98 if "file_record" in io_db:
99 io_db["file_record"].close()
102 def obey(command, prefix, replay=False, do_record=False):
103 """Call function from commands_db mapped to command's first token.
105 Tokenize command string with shlex.split(comments=True). If replay is set,
106 a non-meta command from the commands_db merely triggers obey() on the next
107 command from the records file. If not, non-meta commands set
108 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
109 do_record is set, are recorded to io_db["record_chunk"], and save_world()
110 is called (and io_db["record_chunk"] written) if 15 seconds have passed
111 since the last time it was called. The prefix string is inserted into the
112 server's input message between its beginning 'input ' and ':'. All activity
113 is preceded by a server_test() call. Commands that start with a lowercase
114 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
118 print("input " + prefix + ": " + command)
120 tokens = shlex.split(command, comments=True)
121 except ValueError as err:
122 print("Can't tokenize command string: " + str(err) + ".")
124 if len(tokens) > 0 and tokens[0] in commands_db \
125 and len(tokens) == commands_db[tokens[0]][0] + 1:
126 if commands_db[tokens[0]][1]:
127 commands_db[tokens[0]][2](*tokens[1:])
128 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
129 print("Ignoring lowercase-starting commands when world inactive.")
131 print("Due to replay mode, reading command as 'go on in record'.")
132 line = io_db["file_record"].readline()
134 obey(line.rstrip(), io_db["file_record"].prefix
135 + str(io_db["file_record"].line_n))
136 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
138 print("Reached end of record file.")
140 commands_db[tokens[0]][2](*tokens[1:])
142 io_db["record_chunk"] += command + "\n"
143 if time.time() > io_db["save_wait"] + 15:
144 atomic_write(io_db["path_record"], io_db["record_chunk"],
146 if world_db["WORLD_ACTIVE"]:
148 io_db["record_chunk"] = ""
149 io_db["save_wait"] = time.time()
150 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
151 elif 0 != len(tokens):
152 print("Invalid command/argument, or bad number of tokens.")
155 def atomic_write(path, text, do_append=False, delete=True):
156 """Atomic write of text to file at path, appended if do_append is set."""
157 path_tmp = path + io_db["tmp_suffix"]
161 if os.access(path, os.F_OK):
162 shutil.copyfile(path, path_tmp)
163 file = open(path_tmp, mode)
164 strong_write(file, text)
166 if delete and os.access(path, os.F_OK):
168 os.rename(path_tmp, path)
172 """Save all commands needed to reconstruct current world state."""
175 string = string.replace("\u005C", '\u005C\u005C')
176 return '"' + string.replace('"', '\u005C"') + '"'
181 if key == "MAP" or world_db["Things"][id][key]:
182 map = world_db["MAP"] if key == "MAP" \
183 else world_db["Things"][id][key]
184 length = world_db["MAP_LENGTH"]
185 for i in range(length):
186 line = map[i * length:(i * length) + length].decode()
187 string = string + key + " " + str(i) + " " + quote(line) \
194 for memthing in world_db["Things"][id]["T_MEMTHING"]:
195 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
196 str(memthing[1]) + " " + str(memthing[2]) + "\n"
199 def helper(category, id_string, special_keys={}):
201 for id in world_db[category]:
202 string = string + id_string + " " + str(id) + "\n"
203 for key in world_db[category][id]:
204 if not key in special_keys:
205 x = world_db[category][id][key]
206 argument = quote(x) if str == type(x) else str(x)
207 string = string + key + " " + argument + "\n"
208 elif special_keys[key]:
209 string = string + special_keys[key](id)
214 if (dict != type(world_db[key])
215 and key != "altar" # #
216 and key != "MAP" and key != "WORLD_ACTIVE"):
217 string = string + key + " " + str(world_db[key]) + "\n"
218 string = string + mapsetter("MAP")()
219 string = string + helper("ThingActions", "TA_ID")
220 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
221 for id in world_db["ThingTypes"]:
222 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
223 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
224 string = string + helper("Things", "T_ID",
225 {"T_CARRIES": False, "carried": False,
226 "T_MEMMAP": mapsetter("T_MEMMAP"),
227 "T_MEMTHING": memthing, "fovmap": False,
228 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
229 for id in world_db["Things"]:
230 if [] != world_db["Things"][id]["T_CARRIES"]:
231 string = string + "T_ID " + str(id) + "\n"
232 for carried_id in world_db["Things"][id]["T_CARRIES"]:
233 string = string + "T_CARRIES " + str(carried_id) + "\n"
234 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
235 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
236 atomic_write(io_db["path_save"], string)
239 def obey_lines_in_file(path, name, do_record=False):
240 """Call obey() on each line of path's file, use name in input prefix."""
241 file = open(path, "r")
243 for line in file.readlines():
244 obey(line.rstrip(), name + "file line " + str(line_n),
250 def parse_command_line_arguments():
251 """Return settings values read from command line arguments."""
252 parser = argparse.ArgumentParser()
253 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
255 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
257 parser.add_argument('-v', dest='verbose', action='store_true')
258 opts, unknown = parser.parse_known_args()
263 """Ensure valid server out file belonging to current process.
265 This is done by comparing io_db["teststring"] to what's found at the start
266 of the current file at io_db["path_out"]. On failure, set
267 io_db["kicked_by_rival"] and raise SystemExit.
269 if not os.access(io_db["path_out"], os.F_OK):
270 raise SystemExit("Server output file has disappeared.")
271 file = open(io_db["path_out"], "r")
272 test = file.readline().rstrip("\n")
274 if test != io_db["teststring"]:
275 io_db["kicked_by_rival"] = True
276 msg = "Server test string in server output file does not match. This" \
277 " indicates that the current server process has been " \
278 "superseded by another one."
279 raise SystemExit(msg)
283 """Return next newline-delimited command from server in file.
285 Keep building return string until a newline is encountered. Pause between
286 unsuccessful reads, and after too much waiting, run server_test().
288 wait_on_fail = 0.03333
293 add = io_db["file_in"].readline()
295 command = command + add
296 if len(command) > 0 and "\n" == command[-1]:
297 command = command[:-1]
300 time.sleep(wait_on_fail)
301 if now + max_wait < time.time():
307 def try_worldstate_update():
308 """Write worldstate file if io_db["worldstate_updateable"] is set."""
309 if io_db["worldstate_updateable"]:
311 def write_map(string, map):
312 for i in range(length):
313 line = map[i * length:(i * length) + length].decode()
314 string = string + line + "\n"
318 if [] == world_db["Things"][0]["T_CARRIES"]:
319 inventory = "(none)\n"
321 for id in world_db["Things"][0]["T_CARRIES"]:
322 type_id = world_db["Things"][id]["T_TYPE"]
323 name = world_db["ThingTypes"][type_id]["TT_NAME"]
324 inventory = inventory + name + "\n"
325 # 7DRL additions: GOD_MOOD, GOD_FAVOR
326 string = str(world_db["TURN"]) + "\n" + \
327 str(world_db["GOD_MOOD"]) + "\n" + \
328 str(world_db["GOD_FAVOR"]) + "\n" + \
329 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
330 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
331 inventory + "%\n" + \
332 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
333 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
334 str(world_db["MAP_LENGTH"]) + "\n"
335 length = world_db["MAP_LENGTH"]
337 fov = bytearray(b' ' * (length ** 2))
339 for pos in [pos for pos in range(length ** 2)
340 if ord_v == world_db["Things"][0]["fovmap"][pos]]:
341 fov[pos] = world_db["MAP"][pos]
342 for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
343 for id in world_db["Things"]
344 if not world_db["Things"][id]["carried"]
345 if world_db["Things"][id]["T_TYPE"] == tid
346 if world_db["Things"][0]["fovmap"][
347 world_db["Things"][id]["T_POSY"] * length
348 + world_db["Things"][id]["T_POSX"]] == ord_v]:
349 type = world_db["Things"][id]["T_TYPE"]
350 c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
351 fov[world_db["Things"][id]["T_POSY"] * length
352 + world_db["Things"][id]["T_POSX"]] = c
353 string = write_map(string, fov)
355 mem = world_db["Things"][0]["T_MEMMAP"][:]
356 for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
357 for mt in world_db["Things"][0]["T_MEMTHING"]
359 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
360 mem[(mt[1] * length) + mt[2]] = ord(c)
361 string = write_map(string, mem)
363 metamapA = bytearray(b'0' * (length ** 2)) # #
364 for id in [id for id in world_db["Things"] # #
365 if not world_db["Things"][id]["carried"] # #
366 if world_db["Things"][id]["T_LIFEPOINTS"] # #
367 if world_db["Things"][0]["fovmap"][ # #
368 world_db["Things"][id]["T_POSY"] * length # #
369 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
370 pos = (world_db["Things"][id]["T_POSY"] * length # #
371 + world_db["Things"][id]["T_POSX"]) # #
372 if id == 0 or world_db["EMPATHY"]: # #
373 type = world_db["Things"][id]["T_TYPE"] # #
374 max_hp = world_db["ThingTypes"][type]["TT_LIFEPOINTS"] # #
375 third_of_hp = max_hp / 3 # #
376 hp = world_db["Things"][id]["T_LIFEPOINTS"] # #
378 if hp > 2 * third_of_hp: # #
380 elif hp > third_of_hp: # #
382 metamapA[pos] = ord('a') + add # #
384 metamapA[pos] = ord('X') # #
385 for mt in world_db["Things"][0]["T_MEMTHING"]: # #
386 pos = mt[1] * length + mt[2] # #
387 if metamapA[pos] < ord('2'): # #
388 metamapA[pos] += 1 # #
389 string = write_map(string, metamapA) # #
391 metamapB = bytearray(b' ' * (length ** 2)) # #
392 for id in [id for id in world_db["Things"] # #
393 if not world_db["Things"][id]["carried"] # #
394 if world_db["Things"][id]["T_LIFEPOINTS"] # #
395 if world_db["Things"][0]["fovmap"][ # #
396 world_db["Things"][id]["T_POSY"] * length # #
397 + world_db["Things"][id]["T_POSX"]] == ord_v]: # #
398 pos = (world_db["Things"][id]["T_POSY"] * length # #
399 + world_db["Things"][id]["T_POSX"]) # #
400 if id == 0 or world_db["EMPATHY"]: # #
401 action = world_db["Things"][id]["T_COMMAND"] # #
403 name = world_db["ThingActions"][action]["TA_NAME"] # #
406 metamapB[pos] = ord(name[0]) # #
407 string = write_map(string, metamapB) # #
409 atomic_write(io_db["path_worldstate"], string, delete=False)
410 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
411 io_db["worldstate_updateable"] = False
415 """Replay game from record file.
417 Use opts.replay as breakpoint turn to which to replay automatically before
418 switching to manual input by non-meta commands in server input file
419 triggering further reads of record file. Ensure opts.replay is at least 1.
420 Run try_worldstate_update() before each interactive obey()/read_command().
424 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
425 " (if so late a turn is to be found).")
426 if not os.access(io_db["path_record"], os.F_OK):
427 raise SystemExit("No record file found to replay.")
428 io_db["file_record"] = open(io_db["path_record"], "r")
429 io_db["file_record"].prefix = "record file line "
430 io_db["file_record"].line_n = 1
431 while world_db["TURN"] < opts.replay:
432 line = io_db["file_record"].readline()
435 obey(line.rstrip(), io_db["file_record"].prefix
436 + str(io_db["file_record"].line_n))
437 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
439 try_worldstate_update()
440 obey(read_command(), "in file", replay=True)
444 """Play game by server input file commands. Before, load save file found.
446 If no save file is found, a new world is generated from the commands in the
447 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
448 command and all that follow via the server input file. Run
449 try_worldstate_update() before each interactive obey()/read_command().
451 if os.access(io_db["path_save"], os.F_OK):
452 obey_lines_in_file(io_db["path_save"], "save")
454 if not os.access(io_db["path_worldconf"], os.F_OK):
455 msg = "No world config file from which to start a new world."
456 raise SystemExit(msg)
457 obey_lines_in_file(io_db["path_worldconf"], "world config ",
459 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
461 try_worldstate_update()
462 obey(read_command(), "in file", do_record=True)
466 """(Re-)make island map.
468 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
469 start with one land cell in the middle, then go into cycle of repeatedly
470 selecting a random sea cell and transforming it into land if it is neighbor
471 to land. The cycle ends when a land cell is due to be created at the map's
472 border. Then put some trees on the map (TODO: more precise algorithm desc).
474 # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
476 def is_neighbor(coordinates, type):
479 length = world_db["MAP_LENGTH"]
481 diag_west = x + (ind > 0)
482 diag_east = x + (ind < (length - 1))
483 pos = (y * length) + x
484 if (y > 0 and diag_east
485 and type == chr(world_db["MAP"][pos - length + ind])) \
487 and type == chr(world_db["MAP"][pos + 1])) \
488 or (y < (length - 1) and diag_east
489 and type == chr(world_db["MAP"][pos + length + ind])) \
490 or (y > 0 and diag_west
491 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
493 and type == chr(world_db["MAP"][pos - 1])) \
494 or (y < (length - 1) and diag_west
495 and type == chr(world_db["MAP"][pos + length - (not ind)])):
499 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
500 length = world_db["MAP_LENGTH"]
501 add_half_width = (not (length % 2)) * int(length / 2)
502 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
504 y = rand.next() % length
505 x = rand.next() % length
506 pos = (y * length) + x
507 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
508 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
510 world_db["MAP"][pos] = ord(".")
511 n_trees = int((length ** 2) / 16)
513 while (i_trees <= n_trees):
514 single_allowed = rand.next() % 32
515 y = rand.next() % length
516 x = rand.next() % length
517 pos = (y * length) + x
518 if "." == chr(world_db["MAP"][pos]) \
519 and ((not single_allowed) or is_neighbor((y, x), "X")):
520 world_db["MAP"][pos] = ord("X")
522 # This all-too-precise replica of the original C code misses iter_limit().
523 n_colons = int((length ** 2) / 16) # #
525 while (i_colons <= n_colons): # #
526 single_allowed = rand.next() % 256 # #
527 y = rand.next() % length # #
528 x = rand.next() % length # #
529 pos = (y * length) + x # #
530 if ("." == chr(world_db["MAP"][pos]) # #
531 and ((not single_allowed) or is_neighbor((y, x), ":"))): # #
532 world_db["MAP"][pos] = ord(":") # #
534 altar_placed = False # #
535 while not altar_placed: # #
536 y = rand.next() % length # #
537 x = rand.next() % length # #
538 pos = (y * length) + x # #
539 if (("." == chr(world_db["MAP"][pos] # #
540 or ":" == chr(world_db["MAP"][pos]))
541 and not is_neighbor((y, x), "X"))): # #
542 world_db["MAP"][pos] = ord("_") # #
543 world_db["altar"] = (y, x) # #
544 altar_placed = True # #
547 def update_map_memory(t, age_map=True):
548 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
550 def age_some_memdepthmap_on_nonfov_cells():
551 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
555 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
556 # if not ord_v == t["fovmap"][pos]
557 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
558 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
559 # if not rand.next() % (2 **
560 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
561 # t["T_MEMDEPTHMAP"][pos] += 1
562 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
563 fovmap = c_pointer_to_bytearray(t["fovmap"])
564 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
566 if not t["T_MEMMAP"]:
567 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
568 if not t["T_MEMDEPTHMAP"]:
569 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
573 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
574 if ord_v == t["fovmap"][pos]]:
575 t["T_MEMDEPTHMAP"][pos] = ord_0
576 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
578 age_some_memdepthmap_on_nonfov_cells()
579 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
580 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
582 for id in [id for id in world_db["Things"]
583 if not world_db["Things"][id]["carried"]]:
584 type = world_db["Things"][id]["T_TYPE"]
585 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
586 y = world_db["Things"][id]["T_POSY"]
587 x = world_db["Things"][id]["T_POSX"]
588 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
589 t["T_MEMTHING"].append((type, y, x))
592 def set_world_inactive():
593 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
595 if os.access(io_db["path_worldstate"], os.F_OK):
596 os.remove(io_db["path_worldstate"])
597 world_db["WORLD_ACTIVE"] = 0
600 def integer_test(val_string, min, max=None):
601 """Return val_string if possible integer >= min and <= max, else None."""
603 val = int(val_string)
604 if val < min or (max is not None and val > max):
608 msg = "Ignoring: Please use integer >= " + str(min)
610 msg += " and <= " + str(max)
616 def setter(category, key, min, max=None):
617 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
620 val = integer_test(val_string, min, max)
624 if category == "Thing":
625 id_store = command_tid
626 decorator = test_Thing_id
627 elif category == "ThingType":
628 id_store = command_ttid
629 decorator = test_ThingType_id
630 elif category == "ThingAction":
631 id_store = command_taid
632 decorator = test_ThingAction_id
636 val = integer_test(val_string, min, max)
638 world_db[category + "s"][id_store.id][key] = val
642 def build_fov_map(t):
643 """Build Thing's FOV map."""
644 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
645 fovmap = c_pointer_to_bytearray(t["fovmap"])
646 map = c_pointer_to_bytearray(world_db["MAP"])
647 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
648 raise RuntimeError("Malloc error in build_fov_Map().")
652 """Send quick usage info to log."""
653 strong_write(io_db["file_out"], "LOG "
654 + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n")
655 strong_write(io_db["file_out"], "LOG "
656 + "Use 'p' to pick up objects, and 'D' to drop them.\n")
657 strong_write(io_db["file_out"], "LOG "
658 + "Some objects can be used (such as: eaten) by 'u' if "
659 + "they are in your inventory. "
660 + "Use 'Up'/'Down' to navigate the inventory.\n")
661 strong_write(io_db["file_out"], "LOG "
662 + "Use 'l' to toggle 'look' mode (move an exploration cursor "
663 + "instead of the player over the map).\n")
664 strong_write(io_db["file_out"], "LOG "
665 + "Use 'PgUp'/PgDn' to scroll the 'Things here' window.\n")
666 strong_write(io_db["file_out"], "LOG See README file for more details.\n")
669 def decrement_lifepoints(t):
670 """Decrement t's lifepoints by 1, and if to zero, corpse it.
672 If t is the player avatar, only blank its fovmap, so that the client may
673 still display memory data. On non-player things, erase fovmap and memory.
674 Dying actors drop all their things.
676 # 7DRL: Also decrements God's mood; deaths heavily so.
677 # 7DRL: Return 1 if death, else 0.
678 t["T_LIFEPOINTS"] -= 1
679 world_db["GOD_MOOD"] -= 1 # #
680 if 0 == t["T_LIFEPOINTS"]:
681 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
682 world_db["GOD_MOOD"] -= sadness # #
683 for id in t["T_CARRIES"]:
684 t["T_CARRIES"].remove(id)
685 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
686 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
687 world_db["Things"][id]["carried"] = False
688 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
689 if world_db["Things"][0] == t:
690 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
691 strong_write(io_db["file_out"], "LOG You die.\n")
692 strong_write(io_db["file_out"],
693 "LOG See README on how to start over.\n")
696 t["T_MEMMAP"] = False
697 t["T_MEMDEPTHMAP"] = False
703 def add_gods_favor(i): # #
704 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
705 def favor_multiplier(i):
707 threshold = math.e * x
708 mood = world_db["GOD_MOOD"]
711 i = i * math.log(mood / x)
712 elif -mood > threshold:
713 i = i / math.log(-mood / x)
715 if -mood > threshold:
716 i = i * math.log(-mood / x)
718 i = i / math.log(mood / x)
720 world_db["GOD_FAVOR"] += favor_multiplier(i)
723 def mv_yx_in_dir_legal(dir, y, x):
724 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
725 dir_c = dir.encode("ascii")[0]
726 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
728 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
729 return (test, libpr.result_y(), libpr.result_x())
732 def enter_altar(): # #
733 """What happens when the player enters the altar."""
734 if world_db["FAVOR_STAGE"] > 9000:
735 strong_write(io_db["file_out"],
736 "LOG You step on a soul-less slab of stone.\n")
738 strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
739 if world_db["FAVOR_STAGE"] == 0:
740 world_db["FAVOR_STAGE"] = 1
741 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
742 + "\"I don't trust you. You intrude on the island's "
743 + "affairs. I think you're a nuisance at best, and a "
744 + "danger to my children at worst. I will give you a "
745 + "chance to lighten my mood, however: For a while now, "
746 + "I've been trying to spread the plant "
747 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
749 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
750 + "\"). I have not been very successful so far. Maybe "
751 + "you can make yourself useful there. I will count "
753 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
754 + " that grows to your favor.\n")
755 elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
756 world_db["FAVOR_STAGE"] = 2
757 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
758 + "\"You could have done worse so far. Maybe you are not "
759 + "the worst to happen to this island since the metal "
760 + "birds threw the great lightning ball. Maybe you can "
761 + "help me spread another plant. It multiplies faster, "
762 + "and it is highly nutritious: "
763 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
765 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_SYMBOL"]
766 + "\"). It is new. I give you the only example. Be very "
767 + "careful with it! I also give you another tool that "
768 + "might be helpful.\n")
769 id = id_setter(-1, "Things")
770 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
772 id = id_setter(-1, "Things")
773 world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
775 elif world_db["FAVOR_STAGE"] == 2 and \
776 0 == len([id for id in world_db["Things"]
777 if world_db["Things"][id]["T_TYPE"]
778 == world_db["PLANT_1"]]):
779 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
780 + "\"I am greatly disappointed that you lost all "
781 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
782 + " this island had. Here is another one. It cost me "
783 + " great work. Be more careful this time.\n")
784 id = id_setter(-1, "Things")
785 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
788 elif world_db["GOD_FAVOR"] > 9000:
789 world_db["FAVOR_STAGE"] = 9001
790 strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
791 + "\"You have proven yourself worthy of my respect. "
792 + "You were a good citizen to the island, and sometimes "
793 + "a better steward to its inhabitants than me. The "
794 + "island shall miss you when you leave. But you have "
795 + "earned the right to do so. Take this "
796 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
797 + " and USE it when you please. It will take you to "
798 + "where you came from. (But do feel free to stay here "
799 + "as long as you like.)\"\n")
800 id = id_setter(-1, "Things")
801 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
806 """Make t do nothing (but loudly, if player avatar)."""
807 if t == world_db["Things"][0]:
808 strong_write(io_db["file_out"], "LOG You wait.\n")
812 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
813 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
814 # 7DRL: Player entering the altar triggers enter_altar().
815 # 7DRL: Player with axe chops down trees.
817 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
818 t["T_POSY"], t["T_POSX"])
819 if 1 == move_result[0]:
820 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
821 hitted = [id for id in world_db["Things"]
822 if world_db["Things"][id] != t
823 if world_db["Things"][id]["T_LIFEPOINTS"]
824 if world_db["Things"][id]["T_POSY"] == move_result[1]
825 if world_db["Things"][id]["T_POSX"] == move_result[2]]
828 if t == world_db["Things"][0]:
829 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
830 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
831 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
833 add_gods_favor(-1) # #
835 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
836 strong_write(io_db["file_out"], "LOG " + hitter_name +
838 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
839 if test and t == world_db["Things"][0]: # #
840 add_gods_favor(-test) # #
842 if (ord("X") == world_db["MAP"][pos] # #
843 or ord("|") == world_db["MAP"][pos]): # #
844 carries_axe = False # #
845 for id in t["T_CARRIES"]: # #
846 type = world_db["Things"][id]["T_TYPE"] # #
847 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # #
848 carries_axe = True # #
851 axe_name = world_db["ThingTypes"][type]["TT_NAME"] # #
852 if t == world_db["Things"][0]: # #
853 strong_write(io_db["file_out"], "LOG With your " # #
855 + ", you chop!\n") # #
856 if ord("X") == world_db["MAP"][pos]: # #
857 add_gods_favor(-1) # #
858 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
859 case_X = world_db["MAP"][pos] == ord("X") # #
860 if (chop_power > 0 # #
862 0 == int(rand.next() / chop_power)) # #
863 or (not case_X and # #
864 0 == int(rand.next() / (3 * chop_power))))): # #
865 if t == world_db["Things"][0]: # #
866 strong_write(io_db["file_out"], # #
867 "LOG You chop it down.\n") # #
868 if world_db["MAP"][pos] == ord("X"): # #
869 add_gods_favor(-10) # #
870 world_db["MAP"][pos] = ord(".") # #
871 i = 3 if case_X else 1 # #
872 for i in range(i): # #
873 id = id_setter(-1, "Things") # #
874 world_db["Things"][id] = \
875 new_Thing(world_db["LUMBER"], # #
876 (move_result[1], move_result[2])) # #
879 passable = ("." == chr(world_db["MAP"][pos]) or
880 ":" == chr(world_db["MAP"][pos]) or # #
881 "_" == chr(world_db["MAP"][pos])) # #
882 dir = [dir for dir in directions_db
883 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
885 t["T_POSY"] = move_result[1]
886 t["T_POSX"] = move_result[2]
887 for id in t["T_CARRIES"]:
888 world_db["Things"][id]["T_POSY"] = move_result[1]
889 world_db["Things"][id]["T_POSX"] = move_result[2]
891 if t == world_db["Things"][0]:
892 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
893 if (move_result[1] == world_db["altar"][0] and # #
894 move_result[2] == world_db["altar"][1]): # #
896 elif t == world_db["Things"][0]:
897 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
900 def actor_pick_up(t):
901 """Make t pick up (topmost?) Thing from ground into inventory.
903 Define topmostness by how low the thing's type ID is.
905 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
906 # 7DRL: Only player picks up non-food.
907 used_slots = len(t["T_CARRIES"]) # #
908 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
909 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
910 if not world_db["Things"][id]["carried"]
911 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
912 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
916 tid = world_db["Things"][iid]["T_TYPE"]
917 if lowest_tid == -1 or tid < lowest_tid:
918 if (t != world_db["Things"][0] and # #
919 world_db["ThingTypes"][tid]["TT_TOOL"] != "food"):
923 world_db["Things"][id]["carried"] = True
924 type = world_db["Things"][id]["T_TYPE"] # #
925 if (t != world_db["Things"][0] # #
926 and world_db["Things"][id]["T_PLAYERDROP"] # #
927 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # #
928 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # #
929 add_gods_favor(score) # #
930 world_db["Things"][id]["T_PLAYERDROP"] = 0 # #
931 t["T_CARRIES"].append(id)
932 if t == world_db["Things"][0]:
933 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
934 elif t == world_db["Things"][0]:
935 err = "You try to pick up an object, but there is none."
936 strong_write(io_db["file_out"], "LOG " + err + "\n")
937 elif t == world_db["Things"][0]: # #
938 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
939 "No storage room to carry more.\n") # #
943 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
944 # TODO: Handle case where T_ARGUMENT matches nothing.
945 if len(t["T_CARRIES"]):
946 id = t["T_CARRIES"][t["T_ARGUMENT"]]
947 t["T_CARRIES"].remove(id)
948 world_db["Things"][id]["carried"] = False
949 if t == world_db["Things"][0]:
950 strong_write(io_db["file_out"], "LOG You drop an object.\n")
951 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
952 elif t == world_db["Things"][0]:
953 err = "You try to drop an object, but you own none."
954 strong_write(io_db["file_out"], "LOG " + err + "\n")
958 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
959 # TODO: Handle case where T_ARGUMENT matches nothing.
960 # 7DLR: Handle SLIPPERS-type Thing use.
961 if len(t["T_CARRIES"]):
962 id = t["T_CARRIES"][t["T_ARGUMENT"]]
963 type = world_db["Things"][id]["T_TYPE"]
964 if type == world_db["SLIPPERS"]: # #
965 if t == world_db["Things"][0]: # #
966 strong_write(io_db["file_out"], "LOG You use the " # #
967 + world_db["ThingTypes"][type]["TT_NAME"] # #
968 + ". It glows in wondrous colors, and emits " # #
969 + "a sound as if from a dying cat. The " # #
970 + "Island God laughs.\n") # #
971 t["T_LIFEPOINTS"] = 1 # #
972 decrement_lifepoints(t) # #
973 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # #
974 and t == world_db["Things"][0]): # #
975 strong_write(io_db["file_out"], # #
976 "LOG To use this item for chopping, move " # #
977 "towards a tree while carrying it in " # #
978 "your inventory.\n") # #
979 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"): # #
980 pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
981 if (world_db["MAP"][pos] == ord("X") # #
982 or world_db["MAP"][pos] == ord("|")): # #
983 strong_write(io_db["file_out"], # #
984 "LOG Can't build when standing on barrier.\n") # #
986 for id in [id for id in world_db["Things"]
987 if not world_db["Things"][id] == t
988 if not world_db["Things"][id]["carried"]
989 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
990 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
991 strong_write(io_db["file_out"],
992 "LOG Can't build when standing objects.\n") # #
994 for id in t["T_CARRIES"]: # #
995 type_tool = world_db["Things"][id]["T_TYPE"] # #
996 if (world_db["ThingTypes"][type_tool]["TT_TOOL"] # #
1000 for id in t["T_CARRIES"]: # #
1001 type_material = world_db["Things"][id]["T_TYPE"] # #
1002 if (world_db["ThingTypes"][type_material]["TT_TOOL"] # #
1006 if wood_id != None: # #
1007 t["T_CARRIES"].remove(wood_id) # #
1008 del world_db["Things"][wood_id] # #
1009 world_db["MAP"][pos] = ord("|") # #
1010 strong_write(io_db["file_out"], "LOG With your " # #
1011 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
1012 + " you build a wooden barrier from your " # #
1013 + world_db["ThingTypes"][type_material] # #
1017 strong_write(io_db["file_out"], "LOG You can't use a " # #
1018 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
1019 + " without some wood in your inventory.\n") # #
1020 elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
1021 t["T_CARRIES"].remove(id)
1022 del world_db["Things"][id]
1023 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1024 if t == world_db["Things"][0]:
1025 strong_write(io_db["file_out"],
1026 "LOG You consume this object.\n")
1027 elif t == world_db["Things"][0]:
1028 strong_write(io_db["file_out"],
1029 "LOG You try to use this object, but fail.\n")
1030 elif t == world_db["Things"][0]:
1031 strong_write(io_db["file_out"],
1032 "LOG You try to use an object, but you own none.\n")
1035 def thingproliferation(t, prol_map):
1036 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1038 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1039 marked "." in prol_map. If there are several map cell candidates, one is
1042 # 7DRL: success increments God's mood
1043 # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1044 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1045 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1047 for dir in [directions_db[key] for key in directions_db]:
1048 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1049 pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1050 if mv_result[0] and \
1051 (ord(":") == prol_map[pos] # #
1052 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1053 and ord(".") == prol_map[pos])):
1054 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1055 # * world_db["MAP_LENGTH"]
1057 candidates.append((mv_result[1], mv_result[2]))
1059 i = rand.next() % len(candidates)
1060 id = id_setter(-1, "Things")
1061 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1062 world_db["Things"][id] = newT
1063 animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1065 world_db["GOD_MOOD"] += animacy # #
1067 world_db["GOD_MOOD"] += 1 # #
1068 if (world_db["FAVOR_STAGE"] > 0 # #
1069 and t["T_TYPE"] == world_db["PLANT_0"]): # #
1070 world_db["GOD_FAVOR"] += 5 # #
1071 elif t["T_TYPE"] == world_db["PLANT_1"]: # #
1072 world_db["GOD_FAVOR"] += 25 # #
1076 """If t's HP < max, increment them if well-nourished, maybe waiting."""
1077 # 7DRL: Successful heals increment God's mood.
1078 if t["T_LIFEPOINTS"] < \
1079 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1080 wait_id = [id for id in world_db["ThingActions"]
1081 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1082 wait_divider = 8 if t["T_COMMAND"] == wait_id else 1
1083 testval = int(abs(t["T_SATIATION"]) / wait_divider)
1084 if (testval <= 1 or 1 == (rand.next() % testval)):
1085 t["T_LIFEPOINTS"] += 1
1086 if t != world_db["Things"][0]: # #
1087 world_db["GOD_MOOD"] += 1 # #
1088 if t == world_db["Things"][0]:
1089 strong_write(io_db["file_out"], "LOG You heal.\n")
1092 def hunger_per_turn(type_id):
1093 """The amount of satiation score lost per turn for things of given type."""
1094 return int(math.sqrt(world_db["ThingTypes"][type_id]["TT_LIFEPOINTS"]))
1098 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1099 if t["T_SATIATION"] > -32768:
1100 #max_hp = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]
1101 t["T_SATIATION"] -= hunger_per_turn(t["T_TYPE"]) # int(math.sqrt(max_hp))
1102 if 0 != t["T_SATIATION"] and 0 == int(rand.next() / abs(t["T_SATIATION"])):
1103 if t == world_db["Things"][0]:
1104 if t["T_SATIATION"] < 0:
1105 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
1107 strong_write(io_db["file_out"],
1108 "LOG You suffer from over-eating.\n")
1109 decrement_lifepoints(t)
1112 def get_dir_to_target(t, filter):
1113 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1115 The path-wise nearest target is chosen, via the shortest available path.
1116 Target must not be t. On succcess, return positive value, else False.
1118 "a": Thing in FOV is below a certain distance, animate, but of ThingType
1119 that is not t's, and starts out weaker than t is; build path as
1120 avoiding things of t's ThingType
1121 "f": neighbor cell (not inhabited by any animate Thing) further away from
1122 animate Thing not further than x steps away and in FOV and of a
1123 ThingType that is not t's, and starts out stronger or as strong as t
1124 is currently; or (cornered), if no such flight cell, but Thing of
1125 above criteria is too near,1 a cell closer to it, or, if less near,
1127 "c": Thing in memorized map is consumable
1128 "s": memory map cell with greatest-reachable degree of unexploredness
1131 def zero_score_map_where_char_on_memdepthmap(c):
1132 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1133 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1134 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1135 # set_map_score(i, 0)
1136 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1137 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1138 raise RuntimeError("No score map allocated for "
1139 "zero_score_map_where_char_on_memdepthmap().")
1141 def set_map_score(pos, score):
1142 test = libpr.set_map_score(pos, score)
1144 raise RuntimeError("No score map allocated for set_map_score().")
1146 def get_map_score(pos):
1147 result = libpr.get_map_score(pos)
1149 raise RuntimeError("No score map allocated for get_map_score().")
1153 if t["fovmap"] and ("a" == filter or "f" == filter):
1154 for id in world_db["Things"]:
1155 Thing = world_db["Things"][id]
1156 if Thing != t and Thing["T_LIFEPOINTS"] and \
1157 t["T_TYPE"] != Thing["T_TYPE"] and \
1158 'v' == chr(t["fovmap"][(Thing["T_POSY"]
1159 * world_db["MAP_LENGTH"])
1160 + Thing["T_POSX"]]):
1161 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1162 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1163 t["T_LIFEPOINTS"]) \
1164 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1167 elif t["T_MEMMAP"] and "c" == filter:
1168 for mt in t["T_MEMTHING"]:
1169 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1171 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1175 def set_cells_passable_on_memmap_to_65534_on_scoremap():
1176 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1177 # ord_dot = ord(".")
1178 # memmap = t["T_MEMMAP"]
1179 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1180 # if ord_dot == memmap[i]]:
1181 # set_map_score(i, 65534) # i.e. 65535-1
1182 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1183 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1184 raise RuntimeError("No score map allocated for "
1185 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1187 def init_score_map():
1188 test = libpr.init_score_map()
1190 raise RuntimeError("Malloc error in init_score_map().")
1192 ord_blank = ord(" ")
1193 set_cells_passable_on_memmap_to_65534_on_scoremap()
1195 for id in world_db["Things"]:
1196 Thing = world_db["Things"][id]
1197 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1199 if t != Thing and Thing["T_LIFEPOINTS"] and \
1200 t["T_TYPE"] != Thing["T_TYPE"] and \
1201 ord_v == t["fovmap"][pos] and \
1202 t["T_LIFEPOINTS"] > \
1203 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1204 set_map_score(pos, 0)
1205 elif t["T_TYPE"] == Thing["T_TYPE"]:
1206 set_map_score(pos, 65535)
1208 for id in [id for id in world_db["Things"]
1209 if world_db["Things"][id]["T_LIFEPOINTS"]]:
1210 Thing = world_db["Things"][id]
1211 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1213 if t["T_TYPE"] != Thing["T_TYPE"] and \
1214 ord_v == t["fovmap"][pos] and \
1215 t["T_LIFEPOINTS"] <= \
1216 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1217 set_map_score(pos, 0)
1219 for mt in [mt for mt in t["T_MEMTHING"]
1220 if ord_blank != t["T_MEMMAP"][mt[1]
1221 * world_db["MAP_LENGTH"]
1223 if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1224 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1226 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1228 def rand_target_dir(neighbors, cmp, dirs):
1231 for i in range(len(dirs)):
1232 if cmp == neighbors[i]:
1233 candidates.append(dirs[i])
1235 return candidates[rand.next() % n_candidates] if n_candidates else 0
1237 def get_neighbor_scores(dirs, eye_pos):
1239 if libpr.ready_neighbor_scores(eye_pos):
1240 raise RuntimeError("No score map allocated for " +
1241 "ready_neighbor_scores.()")
1242 for i in range(len(dirs)):
1243 scores.append(libpr.get_neighbor_score(i))
1246 def get_dir_from_neighbors():
1247 dir_to_target = False
1249 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1250 neighbors = get_neighbor_scores(dirs, eye_pos)
1252 inhabited = [world_db["Things"][id]["T_POSY"]
1253 * world_db["MAP_LENGTH"]
1254 + world_db["Things"][id]["T_POSX"]
1255 for id in world_db["Things"]
1256 if world_db["Things"][id]["T_LIFEPOINTS"]]
1257 for i in range(len(dirs)):
1258 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1259 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1261 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1262 neighbors[i] = 65535
1264 minmax_start = 0 if "f" == filter else 65535 - 1
1265 minmax_neighbor = minmax_start
1266 for i in range(len(dirs)):
1267 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1268 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1269 or ("f" != filter and minmax_neighbor > neighbors[i]):
1270 minmax_neighbor = neighbors[i]
1271 if minmax_neighbor != minmax_start:
1272 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1274 if not dir_to_target:
1275 if 1 == get_map_score(eye_pos):
1276 dir_to_target = rand_target_dir(neighbors, 0, dirs)
1277 elif 3 >= get_map_score(eye_pos):
1278 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1280 world_db["ThingActions"][id]["TA_NAME"]
1283 elif dir_to_target and 3 < get_map_score(eye_pos):
1285 elif "a" == filter and 10 <= get_map_score(eye_pos):
1287 return dir_to_target
1289 dir_to_target = False
1291 run_i = 9 + 1 if "s" == filter else 1
1292 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1295 mem_depth_c = b'9' if b' ' == mem_depth_c \
1296 else bytes([mem_depth_c[0] - 1])
1297 if libpr.dijkstra_map():
1298 raise RuntimeError("No score map allocated for dijkstra_map().")
1299 dir_to_target = get_dir_from_neighbors()
1300 libpr.free_score_map()
1301 if dir_to_target and str == type(dir_to_target):
1302 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1303 if world_db["ThingActions"][id]["TA_NAME"]
1305 t["T_ARGUMENT"] = ord(dir_to_target)
1306 return dir_to_target
1309 def standing_on_food(t):
1310 """Return True/False whether t is standing on a consumable."""
1311 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1312 if not world_db["Things"][id]["carried"]
1313 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1314 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1315 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1316 ["TT_TOOL"] == "food"]:
1321 def get_inventory_slot_to_consume(t):
1322 """Return invent. slot of healthiest consumable(if any healthy),else -1."""
1326 hunger_u = hunger_per_turn(t["T_TYPE"])
1327 type = [id for id in world_db["ThingActions"]
1328 if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
1329 consume_hungering = world_db["ThingActions"][type]["TA_EFFORT"] * hunger_u
1330 for id in t["T_CARRIES"]:
1331 type = world_db["Things"][id]["T_TYPE"]
1332 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1333 and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
1334 nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1335 tmp_cmp = abs(t["T_SATIATION"] + nutvalue - consume_hungering)
1336 if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1337 or tmp_cmp < cmp_food:
1345 """Determine next command/argment for actor t via AI algorithms.
1347 AI will look for, and move towards, enemies (animate Things not of their
1348 own ThingType); if they see none, they will consume consumables in their
1349 inventory; if there are none, they will pick up what they stand on if they
1350 stand on consumables; if they stand on none, they will move towards the
1351 next consumable they see or remember on the map; if they see or remember
1352 none, they will explore parts of the map unseen since ever or for at least
1353 one turn; if there is nothing to explore, they will simply wait.
1355 # 7DRL add: Don't pick up or search things when inventory is full.
1356 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1357 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1358 if not get_dir_to_target(t, "f"):
1359 sel = get_inventory_slot_to_consume(t)
1361 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1362 if world_db["ThingActions"][id]["TA_NAME"]
1364 t["T_ARGUMENT"] = sel
1365 elif standing_on_food(t) \
1366 and (len(t["T_CARRIES"]) < # #
1367 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1368 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1369 if world_db["ThingActions"][id]["TA_NAME"]
1372 (len(t["T_CARRIES"]) < # #
1373 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1374 and get_dir_to_target(t, "c"))) and \
1375 (not get_dir_to_target(t, "a")):
1376 get_dir_to_target(t, "s")
1380 """Run game world and its inhabitants until new player input expected."""
1382 whilebreaker = False
1383 while world_db["Things"][0]["T_LIFEPOINTS"]:
1384 proliferable_map = world_db["MAP"][:]
1385 for id in [id for id in world_db["Things"]
1386 if not world_db["Things"][id]["carried"]]:
1387 y = world_db["Things"][id]["T_POSY"]
1388 x = world_db["Things"][id]["T_POSX"]
1389 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1390 for id in [id for id in world_db["Things"]]: # Only what's from start!
1391 if not id in world_db["Things"] or \
1392 world_db["Things"][id]["carried"]: # May have been consumed or
1393 continue # picked up during turn …
1394 Thing = world_db["Things"][id]
1395 if Thing["T_LIFEPOINTS"]:
1396 if not Thing["T_COMMAND"]:
1397 update_map_memory(Thing)
1404 if Thing["T_LIFEPOINTS"]:
1405 Thing["T_PROGRESS"] += 1
1406 taid = [a for a in world_db["ThingActions"]
1407 if a == Thing["T_COMMAND"]][0]
1408 ThingAction = world_db["ThingActions"][taid]
1409 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1410 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1411 Thing["T_COMMAND"] = 0
1412 Thing["T_PROGRESS"] = 0
1413 thingproliferation(Thing, proliferable_map)
1416 world_db["TURN"] += 1
1419 def new_Thing(type, pos=(0, 0)):
1420 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1422 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1427 "T_PLAYERDROP": 0, # #
1435 "T_MEMDEPTHMAP": False,
1438 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1439 build_fov_map(thing)
1443 def id_setter(id, category, id_store=False, start_at_1=False):
1444 """Set ID of object of category to manipulate ID unused? Create new one.
1446 The ID is stored as id_store.id (if id_store is set). If the integer of the
1447 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1448 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1449 always returned when no new object is created, otherwise the new object's
1452 min = 0 if start_at_1 else -1
1454 id = integer_test(id, min)
1456 if id in world_db[category]:
1461 if (start_at_1 and 0 == id) \
1462 or ((not start_at_1) and (id < 0)):
1463 id = 0 if start_at_1 else -1
1466 if id not in world_db[category]:
1474 """Send PONG line to server output file."""
1475 strong_write(io_db["file_out"], "PONG\n")
1479 """Abort server process."""
1480 if None == opts.replay:
1481 if world_db["WORLD_ACTIVE"]:
1483 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1484 raise SystemExit("received QUIT command")
1487 def command_thingshere(str_y, str_x):
1488 """Write to out file list of Things known to player at coordinate y, x."""
1489 # 7DRL: terrain, too
1490 if world_db["WORLD_ACTIVE"]:
1491 y = integer_test(str_y, 0, 255)
1492 x = integer_test(str_x, 0, 255)
1493 length = world_db["MAP_LENGTH"]
1494 if None != y and None != x and y < length and x < length:
1495 pos = (y * world_db["MAP_LENGTH"]) + x
1496 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1497 pos = y * world_db["MAP_LENGTH"] + x; # #
1498 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1499 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1500 for id in world_db["Things"]
1501 if not world_db["Things"][id]["carried"]
1502 if world_db["Things"][id]["T_TYPE"] == tid
1503 if y == world_db["Things"][id]["T_POSY"]
1504 if x == world_db["Things"][id]["T_POSX"]]:
1505 type = world_db["Things"][id]["T_TYPE"]
1506 name = world_db["ThingTypes"][type]["TT_NAME"]
1507 strong_write(io_db["file_out"], name + "\n")
1509 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1510 for mt in world_db["Things"][0]["T_MEMTHING"]
1511 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1512 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1513 strong_write(io_db["file_out"], name + "\n")
1514 if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"): # #
1515 name = "(terrain: SEA)" # #
1516 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."): # #
1517 name = "(terrain: EARTH)" # #
1518 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"): # #
1519 name = "(terrain: SOIL)" # #
1520 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"): # #
1521 name = "(terrain: TREE)" # #
1522 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"): # #
1523 name = "(terrain: WALL)" # #
1524 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"): # #
1525 name = "(terrain: ALTAR)" # #
1528 strong_write(io_db["file_out"], name + "\n") # #
1529 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1531 print("Ignoring: Invalid map coordinates.")
1533 print("Ignoring: Command only works on existing worlds.")
1536 def play_commander(action, args=False):
1537 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1539 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1543 id = [x for x in world_db["ThingActions"]
1544 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1545 world_db["Things"][0]["T_COMMAND"] = id
1548 def set_command_and_argument_int(str_arg):
1549 val = integer_test(str_arg, 0, 255)
1551 world_db["Things"][0]["T_ARGUMENT"] = val
1554 def set_command_and_argument_movestring(str_arg):
1555 if str_arg in directions_db:
1556 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1559 print("Ignoring: Argument must be valid direction string.")
1561 if action == "move":
1562 return set_command_and_argument_movestring
1564 return set_command_and_argument_int
1569 def command_seedrandomness(seed_string):
1570 """Set rand seed to int(seed_string)."""
1571 val = integer_test(seed_string, 0, 4294967295)
1576 def command_makeworld(seed_string):
1577 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1579 Seed rand with seed. Do more only with a "wait" ThingAction and
1580 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1581 world_db["Things"] emptied, call make_map() and set
1582 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1583 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1584 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1585 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1589 # def free_pos(plant=False):
1590 def free_pos(plant=False): # #
1593 err = "Space to put thing on too hard to find. Map too small?"
1595 y = rand.next() % world_db["MAP_LENGTH"]
1596 x = rand.next() % world_db["MAP_LENGTH"]
1597 pos = y * world_db["MAP_LENGTH"] + x;
1599 and "." == chr(world_db["MAP"][pos])) \
1600 or ":" == chr(world_db["MAP"][pos]): # #
1604 raise SystemExit(err)
1605 # Replica of C code, wrongly ignores animatedness of new Thing.
1606 pos_clear = (0 == len([id for id in world_db["Things"]
1607 if world_db["Things"][id]["T_LIFEPOINTS"]
1608 if world_db["Things"][id]["T_POSY"] == y
1609 if world_db["Things"][id]["T_POSX"] == x]))
1614 val = integer_test(seed_string, 0, 4294967295)
1618 player_will_be_generated = False
1619 playertype = world_db["PLAYER_TYPE"]
1620 for ThingType in world_db["ThingTypes"]:
1621 if playertype == ThingType:
1622 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1623 player_will_be_generated = True
1625 if not player_will_be_generated:
1626 print("Ignoring: No player type with start number >0 defined.")
1629 for ThingAction in world_db["ThingActions"]:
1630 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1633 print("Ignoring: No thing action with name 'wait' defined.")
1635 for name in specials: # #
1636 if world_db[name] not in world_db["ThingTypes"]: # #
1637 print("Ignoring: No valid " + name + " set.") # #
1639 world_db["Things"] = {}
1641 world_db["WORLD_ACTIVE"] = 1
1642 world_db["TURN"] = 1
1643 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1644 id = id_setter(-1, "Things")
1645 world_db["Things"][id] = new_Thing(playertype, free_pos())
1646 if not world_db["Things"][0]["fovmap"]:
1647 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1648 world_db["Things"][0]["fovmap"] = empty_fovmap
1649 update_map_memory(world_db["Things"][0])
1650 for type in world_db["ThingTypes"]:
1651 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1652 if type != playertype:
1653 id = id_setter(-1, "Things")
1654 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1655 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1656 strong_write(io_db["file_out"], "NEW_WORLD\n")
1660 def command_maplength(maplength_string):
1661 """Redefine map length. Invalidate map, therefore lose all things on it."""
1662 val = integer_test(maplength_string, 1, 256)
1664 world_db["MAP_LENGTH"] = val
1665 world_db["MAP"] = False
1666 set_world_inactive()
1667 world_db["Things"] = {}
1668 libpr.set_maplength(val)
1671 def command_worldactive(worldactive_string):
1672 """Toggle world_db["WORLD_ACTIVE"] if possible.
1674 An active world can always be set inactive. An inactive world can only be
1675 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1676 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1677 Also call log_help().
1679 # 7DRL: altar must be on map, and specials must be set for active world.
1680 val = integer_test(worldactive_string, 0, 1)
1682 if 0 != world_db["WORLD_ACTIVE"]:
1684 set_world_inactive()
1686 print("World already active.")
1687 elif 0 == world_db["WORLD_ACTIVE"]:
1689 for ThingAction in world_db["ThingActions"]:
1690 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1693 player_exists = False
1694 for Thing in world_db["Things"]:
1696 player_exists = True
1698 specials_set = True # #
1699 for name in specials: # #
1700 if world_db[name] not in world_db["ThingTypes"]: # #
1701 specials_set = False # #
1702 altar_found = False # #
1703 if world_db["MAP"]: # #
1704 pos = world_db["MAP"].find(b'_') # #
1706 y = int(pos / world_db["MAP_LENGTH"]) # #
1707 x = pos % world_db["MAP_LENGTH"] # #
1708 world_db["altar"] = (y, x) # #
1709 altar_found = True # #
1710 if wait_exists and player_exists and world_db["MAP"] \
1711 and specials_set: # #
1712 for id in world_db["Things"]:
1713 if world_db["Things"][id]["T_LIFEPOINTS"]:
1714 build_fov_map(world_db["Things"][id])
1716 update_map_memory(world_db["Things"][id], False)
1717 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1718 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1719 world_db["Things"][0]["fovmap"] = empty_fovmap
1720 world_db["WORLD_ACTIVE"] = 1
1723 print("Ignoring: Not all conditions for world activation met.")
1726 def specialtypesetter(name): # #
1727 """Setter world_db[name], deactivating world if set int no ThingType."""
1728 def helper(str_int):
1729 val = integer_test(str_int, 0)
1731 world_db[name] = val
1732 if world_db["WORLD_ACTIVE"] \
1733 and world_db[name] not in world_db["ThingTypes"]:
1734 world_db["WORLD_ACTIVE"] = 0
1735 print(name + " fits no known ThingType, deactivating world.")
1739 def test_for_id_maker(object, category):
1740 """Return decorator testing for object having "id" attribute."""
1743 if hasattr(object, "id"):
1746 print("Ignoring: No " + category +
1747 " defined to manipulate yet.")
1752 def command_tid(id_string):
1753 """Set ID of Thing to manipulate. ID unused? Create new one.
1755 Default new Thing's type to the first available ThingType, others: zero.
1757 id = id_setter(id_string, "Things", command_tid)
1759 if world_db["ThingTypes"] == {}:
1760 print("Ignoring: No ThingType to settle new Thing in.")
1762 type = list(world_db["ThingTypes"].keys())[0]
1763 world_db["Things"][id] = new_Thing(type)
1766 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1770 def command_tcommand(str_int):
1771 """Set T_COMMAND of selected Thing."""
1772 val = integer_test(str_int, 0)
1774 if 0 == val or val in world_db["ThingActions"]:
1775 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1777 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1781 def command_ttype(str_int):
1782 """Set T_TYPE of selected Thing."""
1783 val = integer_test(str_int, 0)
1785 if val in world_db["ThingTypes"]:
1786 world_db["Things"][command_tid.id]["T_TYPE"] = val
1788 print("Ignoring: ThingType ID belongs to no known ThingType.")
1792 def command_tcarries(str_int):
1793 """Append int(str_int) to T_CARRIES of selected Thing.
1795 The ID int(str_int) must not be of the selected Thing, and must belong to a
1796 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1798 val = integer_test(str_int, 0)
1800 if val == command_tid.id:
1801 print("Ignoring: Thing cannot carry itself.")
1802 elif val in world_db["Things"] \
1803 and not world_db["Things"][val]["carried"]:
1804 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1805 world_db["Things"][val]["carried"] = True
1807 print("Ignoring: Thing not available for carrying.")
1808 # Note that the whole carrying structure is different from the C version:
1809 # Carried-ness is marked by a "carried" flag, not by Things containing
1810 # Things internally.
1814 def command_tmemthing(str_t, str_y, str_x):
1815 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1817 The type must fit to an existing ThingType, and the position into the map.
1819 type = integer_test(str_t, 0)
1820 posy = integer_test(str_y, 0, 255)
1821 posx = integer_test(str_x, 0, 255)
1822 if None != type and None != posy and None != posx:
1823 if type not in world_db["ThingTypes"] \
1824 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1825 print("Ignoring: Illegal value for thing type or position.")
1827 memthing = (type, posy, posx)
1828 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1831 def setter_map(maptype):
1832 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1834 If no map of maptype exists yet, initialize it with ' ' bytes first.
1837 def valid_map_line(str_int, mapline):
1838 val = integer_test(str_int, 0, 255)
1840 if val >= world_db["MAP_LENGTH"]:
1841 print("Illegal value for map line number.")
1842 elif len(mapline) != world_db["MAP_LENGTH"]:
1843 print("Map line length is unequal map width.")
1848 def nonThingMap_helper(str_int, mapline):
1849 val = valid_map_line(str_int, mapline)
1851 length = world_db["MAP_LENGTH"]
1852 if not world_db["MAP"]:
1853 map = bytearray(b' ' * (length ** 2))
1855 map = world_db["MAP"]
1856 map[val * length:(val * length) + length] = mapline.encode()
1857 if not world_db["MAP"]:
1858 world_db["MAP"] = map
1861 def ThingMap_helper(str_int, mapline):
1862 val = valid_map_line(str_int, mapline)
1864 length = world_db["MAP_LENGTH"]
1865 if not world_db["Things"][command_tid.id][maptype]:
1866 map = bytearray(b' ' * (length ** 2))
1868 map = world_db["Things"][command_tid.id][maptype]
1869 map[val * length:(val * length) + length] = mapline.encode()
1870 if not world_db["Things"][command_tid.id][maptype]:
1871 world_db["Things"][command_tid.id][maptype] = map
1873 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1876 def setter_tpos(axis):
1877 """Generate setter for T_POSX or T_POSY of selected Thing.
1879 If world is active, rebuilds animate things' fovmap, player's memory map.
1882 def helper(str_int):
1883 val = integer_test(str_int, 0, 255)
1885 if val < world_db["MAP_LENGTH"]:
1886 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1887 if world_db["WORLD_ACTIVE"] \
1888 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1889 build_fov_map(world_db["Things"][command_tid.id])
1890 if 0 == command_tid.id:
1891 update_map_memory(world_db["Things"][command_tid.id])
1893 print("Ignoring: Position is outside of map.")
1897 def command_ttid(id_string):
1898 """Set ID of ThingType to manipulate. ID unused? Create new one.
1900 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1903 id = id_setter(id_string, "ThingTypes", command_ttid)
1905 world_db["ThingTypes"][id] = {
1906 "TT_NAME": "(none)",
1909 "TT_PROLIFERATE": 0,
1910 "TT_START_NUMBER": 0,
1911 "TT_STORAGE": 0, # #
1918 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1922 def command_ttname(name):
1923 """Set TT_NAME of selected ThingType."""
1924 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1928 def command_tttool(name):
1929 """Set TT_TOOL of selected ThingType."""
1930 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1934 def command_ttsymbol(char):
1935 """Set TT_SYMBOL of selected ThingType. """
1937 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1939 print("Ignoring: Argument must be single character.")
1943 def command_ttcorpseid(str_int):
1944 """Set TT_CORPSE_ID of selected ThingType."""
1945 val = integer_test(str_int, 0)
1947 if val in world_db["ThingTypes"]:
1948 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1950 print("Ignoring: Corpse ID belongs to no known ThignType.")
1953 def command_taid(id_string):
1954 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1956 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1958 id = id_setter(id_string, "ThingActions", command_taid, True)
1960 world_db["ThingActions"][id] = {
1966 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1969 @test_ThingAction_id
1970 def command_taname(name):
1971 """Set TA_NAME of selected ThingAction.
1973 The name must match a valid thing action function. If after the name
1974 setting no ThingAction with name "wait" remains, call set_world_inactive().
1976 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1977 or name == "pick_up":
1978 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1979 if 1 == world_db["WORLD_ACTIVE"]:
1980 wait_defined = False
1981 for id in world_db["ThingActions"]:
1982 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1985 if not wait_defined:
1986 set_world_inactive()
1988 print("Ignoring: Invalid action name.")
1989 # In contrast to the original,naming won't map a function to a ThingAction.
1993 """Call ai() on player Thing, then turn_over()."""
1994 ai(world_db["Things"][0])
1998 """Commands database.
2000 Map command start tokens to ([0]) number of expected command arguments, ([1])
2001 the command's meta-ness (i.e. is it to be written to the record file, is it to
2002 be ignored in replay mode if read from server input file), and ([2]) a function
2006 "QUIT": (0, True, command_quit),
2007 "PING": (0, True, command_ping),
2008 "THINGS_HERE": (2, True, command_thingshere),
2009 "MAKE_WORLD": (1, False, command_makeworld),
2010 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
2011 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
2012 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
2013 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
2014 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
2015 "MAP_LENGTH": (1, False, command_maplength),
2016 "WORLD_ACTIVE": (1, False, command_worldactive),
2017 "MAP": (2, False, setter_map("MAP")),
2018 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
2019 "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")), # #
2020 "PLANT_0": (1, False, specialtypesetter("PLANT_0")), # #
2021 "PLANT_1": (1, False, specialtypesetter("PLANT_1")), # #
2022 "LUMBER": (1, False, specialtypesetter("LUMBER")), # #
2023 "TOOL_0": (1, False, specialtypesetter("TOOL_0")), # #
2024 "EMPATHY": (1, False, setter(None, "EMPATHY", 0, 1)), # #
2025 "TA_ID": (1, False, command_taid),
2026 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
2027 "TA_NAME": (1, False, command_taname),
2028 "TT_ID": (1, False, command_ttid),
2029 "TT_NAME": (1, False, command_ttname),
2030 "TT_TOOL": (1, False, command_tttool),
2031 "TT_SYMBOL": (1, False, command_ttsymbol),
2032 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
2033 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
2034 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
2036 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2038 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2039 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
2040 "T_ID": (1, False, command_tid),
2041 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2042 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2043 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2044 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2045 "T_COMMAND": (1, False, command_tcommand),
2046 "T_TYPE": (1, False, command_ttype),
2047 "T_CARRIES": (1, False, command_tcarries),
2048 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2049 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2050 "T_MEMTHING": (3, False, command_tmemthing),
2051 "T_POSY": (1, False, setter_tpos("Y")),
2052 "T_POSX": (1, False, setter_tpos("X")),
2053 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
2054 "wait": (0, False, play_commander("wait")),
2055 "move": (1, False, play_commander("move")),
2056 "pick_up": (0, False, play_commander("pick_up")),
2057 "drop": (1, False, play_commander("drop", True)),
2058 "use": (1, False, play_commander("use", True)),
2059 "ai": (0, False, command_ai)
2061 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2064 """World state database. With sane default values. (Randomness is in rand.)"""
2073 "FAVOR_STAGE": 0, # #
2086 """Special type settings."""
2087 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"] # #
2089 """Mapping of direction names to internal direction chars."""
2090 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2091 "west": "s", "north-west": "w", "north-east": "e"}
2093 """File IO database."""
2095 "path_save": "save",
2096 "path_record": "record_save",
2097 "path_worldconf": "confserver/world",
2098 "path_server": "server/",
2099 "path_in": "server/in",
2100 "path_out": "server/out",
2101 "path_worldstate": "server/worldstate",
2102 "tmp_suffix": "_tmp",
2103 "kicked_by_rival": False,
2104 "worldstate_updateable": False
2109 libpr = prep_library()
2110 rand = RandomnessIO()
2111 opts = parse_command_line_arguments()
2113 io_db["path_save"] = opts.savefile
2114 io_db["path_record"] = "record_" + opts.savefile
2117 io_db["verbose"] = True
2118 if None != opts.replay:
2122 except SystemExit as exit:
2123 print("ABORTING: " + exit.args[0])
2125 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")