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 eat_vs_hunger_threshold(thingtype):
553 """Return satiation cost of eating for type. Good food for it must be >."""
554 hunger_unit = hunger_per_turn(thingtype)
555 actiontype = [id for id in world_db["ThingActions"]
556 if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
557 return world_db["ThingActions"][actiontype]["TA_EFFORT"] * hunger_unit
560 def update_map_memory(t, age_map=True):
561 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
563 def age_some_memdepthmap_on_nonfov_cells():
564 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
568 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
569 # if not ord_v == t["fovmap"][pos]
570 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
571 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
572 # if not rand.next() % (2 **
573 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
574 # t["T_MEMDEPTHMAP"][pos] += 1
575 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
576 fovmap = c_pointer_to_bytearray(t["fovmap"])
577 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
579 if not t["T_MEMMAP"]:
580 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
581 if not t["T_MEMDEPTHMAP"]:
582 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
586 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
587 if ord_v == t["fovmap"][pos]]:
588 t["T_MEMDEPTHMAP"][pos] = ord_0
589 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
591 age_some_memdepthmap_on_nonfov_cells()
592 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
593 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
595 for id in [id for id in world_db["Things"]
596 if not world_db["Things"][id]["carried"]]:
597 type = world_db["Things"][id]["T_TYPE"]
598 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
599 y = world_db["Things"][id]["T_POSY"]
600 x = world_db["Things"][id]["T_POSX"]
601 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
602 t["T_MEMTHING"].append((type, y, x))
605 def set_world_inactive():
606 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
608 if os.access(io_db["path_worldstate"], os.F_OK):
609 os.remove(io_db["path_worldstate"])
610 world_db["WORLD_ACTIVE"] = 0
613 def integer_test(val_string, min, max=None):
614 """Return val_string if possible integer >= min and <= max, else None."""
616 val = int(val_string)
617 if val < min or (max is not None and val > max):
621 msg = "Ignoring: Please use integer >= " + str(min)
623 msg += " and <= " + str(max)
629 def setter(category, key, min, max=None):
630 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
633 val = integer_test(val_string, min, max)
637 if category == "Thing":
638 id_store = command_tid
639 decorator = test_Thing_id
640 elif category == "ThingType":
641 id_store = command_ttid
642 decorator = test_ThingType_id
643 elif category == "ThingAction":
644 id_store = command_taid
645 decorator = test_ThingAction_id
649 val = integer_test(val_string, min, max)
651 world_db[category + "s"][id_store.id][key] = val
655 def build_fov_map(t):
656 """Build Thing's FOV map."""
657 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
658 fovmap = c_pointer_to_bytearray(t["fovmap"])
659 map = c_pointer_to_bytearray(world_db["MAP"])
660 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
661 raise RuntimeError("Malloc error in build_fov_Map().")
665 """Send quick usage info to log."""
666 log("Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.")
667 log("Use 'p' to pick up objects, and 'D' to drop them.")
668 log("Some objects can be used (such as: eaten) by 'u' if they are in "
669 + "your inventory. Use 'Up'/'Down' to navigate the inventory.")
670 log("Use 'l' to toggle 'look' mode (move an exploration cursor instead of "
671 + "the player over the map).")
672 log("Use 'PgUp'/PgDn' to scroll the 'Things here' window.")
673 log("See README file for more details.")
676 def decrement_lifepoints(t):
677 """Decrement t's lifepoints by 1, and if to zero, corpse it.
679 If t is the player avatar, only blank its fovmap, so that the client may
680 still display memory data. On non-player things, erase fovmap and memory.
681 Dying actors drop all their things.
683 # 7DRL: Also decrements God's mood; deaths heavily so.
684 # 7DRL: Return 1 if death, else 0.
685 t["T_LIFEPOINTS"] -= 1
686 world_db["GOD_MOOD"] -= 1 # #
687 if 0 == t["T_LIFEPOINTS"]:
688 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
689 world_db["GOD_MOOD"] -= sadness # #
690 for id in t["T_CARRIES"]:
691 t["T_CARRIES"].remove(id)
692 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
693 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
694 world_db["Things"][id]["carried"] = False
695 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
696 if world_db["Things"][0] == t:
697 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
699 log("See README on how to start over.")
702 t["T_MEMMAP"] = False
703 t["T_MEMDEPTHMAP"] = False
709 def add_gods_favor(i): # #
710 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
711 def favor_multiplier(i):
713 threshold = math.e * x
714 mood = world_db["GOD_MOOD"]
717 i = i * math.log(mood / x)
718 elif -mood > threshold:
719 i = i / math.log(-mood / x)
721 if -mood > threshold:
722 i = i * math.log(-mood / x)
724 i = i / math.log(mood / x)
726 world_db["GOD_FAVOR"] += favor_multiplier(i)
729 def mv_yx_in_dir_legal(dir, y, x):
730 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
731 dir_c = dir.encode("ascii")[0]
732 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
734 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
735 return (test, libpr.result_y(), libpr.result_x())
738 def enter_altar(): # #
739 """What happens when the player enters the altar."""
740 if world_db["FAVOR_STAGE"] > 9000:
741 log("You step on a soul-less slab of stone.")
743 log("YOU ENTER SACRED GROUND.")
744 if world_db["FAVOR_STAGE"] == 0:
745 world_db["FAVOR_STAGE"] = 1
746 log("The Island God speaks to you: \"I don't trust you. You intrude "
747 + "on the island's affairs. I think you're a nuisance at best, "
748 + "and a danger to my children at worst. I will give you a "
749 + "chance to lighten my mood, however: For a while now, I've "
750 + "been trying to spread the plant "
751 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"] + " (\""
752 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
753 + "\"). I have not been very successful so far. Maybe you can "
754 + "make yourself useful there. I will count each further "
755 + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
756 + " that grows to your favor.\"")
757 elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
758 world_db["FAVOR_STAGE"] = 2
759 log("The Island God speaks to you: \"You could have done worse so "
760 + "far. Maybe you are not the worst to happen to this island "
761 + "since the metal birds threw the great lightning ball. Maybe "
762 + "you can help me spread another plant. It multiplies faster, "
763 + "and it is highly nutritious: "
764 + 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 careful "
767 + "with it! I also give you another tool that may be helpful.\"")
768 id = id_setter(-1, "Things")
769 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
771 id = id_setter(-1, "Things")
772 world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
774 elif world_db["FAVOR_STAGE"] == 2 and \
775 0 == len([id for id in world_db["Things"]
776 if world_db["Things"][id]["T_TYPE"]
777 == world_db["PLANT_1"]]):
778 log("The Island God speaks to you: \"I am greatly disappointed that "
780 + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
781 + " this island had. Here is another one. It cost me great work. "
782 + "Be more careful this time.\"")
783 id = id_setter(-1, "Things")
784 world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
787 elif world_db["GOD_FAVOR"] > 9000:
788 world_db["FAVOR_STAGE"] = 9001
789 log("The Island God speaks to you: \"You have proven yourself worthy"
790 + " of my respect. You were a good citizen to the island, and "
791 + "sometimes a better steward to its inhabitants than me. The "
792 + "island shall miss you when you leave. But you have earned "
793 + "the right to do so. Take this "
794 + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
795 + " and USE it when you please. It will take you to where you "
796 + "came from. (But do feel free to stay here as long as you "
798 id = id_setter(-1, "Things")
799 world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
804 """Make t do nothing (but loudly, if player avatar)."""
805 if t == world_db["Things"][0]:
810 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
811 # 7DRL: Player wounding (worse: killing) others will lower God's favor.
812 # 7DRL: Player entering the altar triggers enter_altar().
813 # 7DRL: Player with axe chops down trees.
815 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
816 t["T_POSY"], t["T_POSX"])
817 if 1 == move_result[0]:
818 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
819 hitted = [id for id in world_db["Things"]
820 if world_db["Things"][id] != t
821 if world_db["Things"][id]["T_LIFEPOINTS"]
822 if world_db["Things"][id]["T_POSY"] == move_result[1]
823 if world_db["Things"][id]["T_POSX"] == move_result[2]]
826 if t == world_db["Things"][0]:
827 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
828 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
829 log("You wound " + hitted_name + ".")
830 add_gods_favor(-1) # #
832 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
833 log(hitter_name +" wounds you.")
834 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
835 if test and t == world_db["Things"][0]: # #
836 add_gods_favor(-test) # #
838 if (ord("X") == world_db["MAP"][pos] # #
839 or ord("|") == world_db["MAP"][pos]): # #
840 carries_axe = False # #
841 for id in t["T_CARRIES"]: # #
842 type = world_db["Things"][id]["T_TYPE"] # #
843 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe": # #
844 carries_axe = True # #
847 axe_name = world_db["ThingTypes"][type]["TT_NAME"] # #
848 if t == world_db["Things"][0]: # #
849 log("With your " + axe_name + ", you chop!\n") # #
850 if ord("X") == world_db["MAP"][pos]: # #
851 add_gods_favor(-1) # #
852 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
853 case_X = world_db["MAP"][pos] == ord("X") # #
854 if (chop_power > 0 # #
856 0 == int(rand.next() / chop_power)) # #
857 or (not case_X and # #
858 0 == int(rand.next() / (3 * chop_power))))): # #
859 if t == world_db["Things"][0]: # #
860 log("You chop it down.") # #
861 if world_db["MAP"][pos] == ord("X"): # #
862 add_gods_favor(-10) # #
863 world_db["MAP"][pos] = ord(".") # #
864 i = 3 if case_X else 1 # #
865 for i in range(i): # #
866 id = id_setter(-1, "Things") # #
867 world_db["Things"][id] = \
868 new_Thing(world_db["LUMBER"], # #
869 (move_result[1], move_result[2])) # #
872 passable = ("." == chr(world_db["MAP"][pos]) or
873 ":" == chr(world_db["MAP"][pos]) or # #
874 "_" == chr(world_db["MAP"][pos])) # #
875 dir = [dir for dir in directions_db
876 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
878 t["T_POSY"] = move_result[1]
879 t["T_POSX"] = move_result[2]
880 for id in t["T_CARRIES"]:
881 world_db["Things"][id]["T_POSY"] = move_result[1]
882 world_db["Things"][id]["T_POSX"] = move_result[2]
884 if t == world_db["Things"][0]:
885 log("You move " + dir + ".")
886 if (move_result[1] == world_db["altar"][0] and # #
887 move_result[2] == world_db["altar"][1]): # #
889 elif t == world_db["Things"][0]:
890 log("You fail to move " + dir + ".")
893 def actor_pick_up(t):
894 """Make t pick up (topmost?) Thing from ground into inventory.
896 Define topmostness by how low the thing's type ID is.
898 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
899 # 7DRL: Non-players pick up nothing but food of good value to them.
900 used_slots = len(t["T_CARRIES"]) # #
901 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
902 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
903 if not world_db["Things"][id]["carried"]
904 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
905 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
908 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"]) # #
910 tid = world_db["Things"][iid]["T_TYPE"]
911 if lowest_tid == -1 or tid < lowest_tid:
912 if (t != world_db["Things"][0] and # #
913 (world_db["ThingTypes"][tid]["TT_TOOL"] != "food" # #
914 or (world_db["ThingTypes"][tid]["TT_TOOLPOWER"] # #
919 world_db["Things"][id]["carried"] = True
920 type = world_db["Things"][id]["T_TYPE"] # #
921 if (t != world_db["Things"][0] # #
922 and world_db["Things"][id]["T_PLAYERDROP"] # #
923 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"): # #
924 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32 # #
925 add_gods_favor(score) # #
926 world_db["Things"][id]["T_PLAYERDROP"] = 0 # #
927 t["T_CARRIES"].append(id)
928 if t == world_db["Things"][0]:
929 log("You pick up an object.")
930 elif t == world_db["Things"][0]:
931 log("You try to pick up an object, but there is none.")
932 elif t == world_db["Things"][0]: # #
933 log("Can't pick up object: No storage room to carry more.") # #
937 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
938 # TODO: Handle case where T_ARGUMENT matches nothing.
939 if len(t["T_CARRIES"]):
940 id = t["T_CARRIES"][t["T_ARGUMENT"]]
941 t["T_CARRIES"].remove(id)
942 world_db["Things"][id]["carried"] = False
943 if t == world_db["Things"][0]:
944 log("You drop an object.")
945 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
946 elif t == world_db["Things"][0]:
947 log("You try to drop an object, but you own none.")
951 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
952 # TODO: Handle case where T_ARGUMENT matches nothing.
953 # 7DLR: Handle SLIPPERS-type Thing use.
954 if len(t["T_CARRIES"]):
955 id = t["T_CARRIES"][t["T_ARGUMENT"]]
956 type = world_db["Things"][id]["T_TYPE"]
957 if type == world_db["SLIPPERS"]: # #
958 if t == world_db["Things"][0]: # #
959 log("You use the " + world_db["ThingTypes"][type]["TT_NAME"] # #
960 + ". It glows in wondrous colors, and emits a sound as " # #
961 + "if from a dying cat. The Island God laughs.\n") # #
962 t["T_LIFEPOINTS"] = 1 # #
963 decrement_lifepoints(t) # #
964 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe" # #
965 and t == world_db["Things"][0]): # #
966 log("To use this item for chopping, move towards a tree while "
967 + "carrying it in your inventory.") # #
968 elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"): # #
969 pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
970 if (world_db["MAP"][pos] == ord("X") # #
971 or world_db["MAP"][pos] == ord("|")): # #
972 log("Can't build when standing on barrier.") # #
974 for id in [id for id in world_db["Things"]
975 if not world_db["Things"][id] == t
976 if not world_db["Things"][id]["carried"]
977 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
978 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
979 log("Can't build when standing objects.") # #
981 for id in t["T_CARRIES"]: # #
982 type_tool = world_db["Things"][id]["T_TYPE"] # #
983 if (world_db["ThingTypes"][type_tool]["TT_TOOL"] # #
987 for id in t["T_CARRIES"]: # #
988 type_material = world_db["Things"][id]["T_TYPE"] # #
989 if (world_db["ThingTypes"][type_material]["TT_TOOL"] # #
993 if wood_id != None: # #
994 t["T_CARRIES"].remove(wood_id) # #
995 del world_db["Things"][wood_id] # #
996 world_db["MAP"][pos] = ord("|") # #
998 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
999 + " you build a wooden barrier from your " # #
1000 + world_db["ThingTypes"][type_material]["TT_NAME"] # #
1003 log("You can't use a " # #
1004 + world_db["ThingTypes"][type_tool]["TT_NAME"] # #
1005 + " without some wood in your inventory.") # #
1006 elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
1007 t["T_CARRIES"].remove(id)
1008 del world_db["Things"][id]
1009 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1010 if t == world_db["Things"][0]:
1011 log("You consume this object.")
1012 elif t == world_db["Things"][0]:
1013 log("You try to use this object, but fail.")
1014 elif t == world_db["Things"][0]:
1015 log("You try to use an object, but you own none.")
1018 def thingproliferation(t, prol_map):
1019 """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1021 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1022 marked "." in prol_map. If there are several map cell candidates, one is
1025 # 7DRL: success increments God's mood
1026 # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1027 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1028 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1030 for dir in [directions_db[key] for key in directions_db]:
1031 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1032 pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1033 if mv_result[0] and \
1034 (ord(":") == prol_map[pos] # #
1035 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1036 and ord(".") == prol_map[pos])):
1037 # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1038 # * world_db["MAP_LENGTH"]
1040 candidates.append((mv_result[1], mv_result[2]))
1042 i = rand.next() % len(candidates)
1043 id = id_setter(-1, "Things")
1044 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1045 world_db["Things"][id] = newT
1046 animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
1048 world_db["GOD_MOOD"] += animacy # #
1050 world_db["GOD_MOOD"] += 1 # #
1051 if (world_db["FAVOR_STAGE"] > 0 # #
1052 and t["T_TYPE"] == world_db["PLANT_0"]): # #
1053 world_db["GOD_FAVOR"] += 5 # #
1054 elif t["T_TYPE"] == world_db["PLANT_1"]: # #
1055 world_db["GOD_FAVOR"] += 25 # #
1059 """If t's HP < max, increment them if well-nourished, maybe waiting."""
1060 # 7DRL: Successful heals increment God's mood.
1061 if t["T_LIFEPOINTS"] < \
1062 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1063 wait_id = [id for id in world_db["ThingActions"]
1064 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1065 wait_divider = 8 if t["T_COMMAND"] == wait_id else 1
1066 testval = int(abs(t["T_SATIATION"]) / wait_divider)
1067 if (testval <= 1 or 1 == (rand.next() % testval)):
1068 t["T_LIFEPOINTS"] += 1
1069 if t != world_db["Things"][0]: # #
1070 world_db["GOD_MOOD"] += 1 # #
1071 if t == world_db["Things"][0]:
1075 def hunger_per_turn(type_id):
1076 """The amount of satiation score lost per turn for things of given type."""
1077 return int(math.sqrt(world_db["ThingTypes"][type_id]["TT_LIFEPOINTS"]))
1081 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1082 if t["T_SATIATION"] > -32768:
1083 #max_hp = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]
1084 t["T_SATIATION"] -= hunger_per_turn(t["T_TYPE"]) # int(math.sqrt(max_hp))
1085 if 0 != t["T_SATIATION"] and 0 == int(rand.next() / abs(t["T_SATIATION"])):
1086 if t == world_db["Things"][0]:
1087 if t["T_SATIATION"] < 0:
1088 log("You suffer from hunger.")
1090 log("You suffer from over-eating.")
1091 decrement_lifepoints(t)
1094 def get_dir_to_target(t, filter):
1095 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1097 The path-wise nearest target is chosen, via the shortest available path.
1098 Target must not be t. On succcess, return positive value, else False.
1100 "a": Thing in FOV is animate, but of ThingType, starts out weaker than t
1101 is, and its corpse would be healthy food for t
1102 "f": move away from an enemy – any visible actor whose thing type has more
1103 TT_LIFEPOINTS than t LIFEPOINTS, and might find t's corpse healthy
1104 food – if it is closer than n steps, where n will shrink as t's hunger
1105 grows; if enemy is too close, move towards (attack) the enemy instead;
1106 if no fleeing is possible, nor attacking useful, wait; don't tread on
1107 non-enemies for fleeing
1108 "c": Thing in memorized map is consumable of sufficient nutrition for t
1109 "s": memory map cell with greatest-reachable degree of unexploredness
1112 def zero_score_map_where_char_on_memdepthmap(c):
1113 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1114 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1115 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1116 # set_map_score(i, 0)
1117 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1118 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1119 raise RuntimeError("No score map allocated for "
1120 "zero_score_map_where_char_on_memdepthmap().")
1122 def set_map_score_at_thingpos(id, score):
1123 pos = world_db["Things"][id]["T_POSY"] * world_db["MAP_LENGTH"] \
1124 + world_db["Things"][id]["T_POSX"]
1125 set_map_score(pos, score)
1127 def set_map_score(pos, score):
1128 test = libpr.set_map_score(pos, score)
1130 raise RuntimeError("No score map allocated for set_map_score().")
1132 def get_map_score(pos):
1133 result = libpr.get_map_score(pos)
1135 raise RuntimeError("No score map allocated for get_map_score().")
1138 def animate_in_fov(Thing):
1139 if Thing["carried"] or Thing == t or not Thing["T_LIFEPOINTS"]:
1141 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] + Thing["T_POSX"]
1142 if ord("v") == t["fovmap"][pos]:
1145 def good_attack_target(v):
1146 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
1147 type = world_db["ThingTypes"][v["T_TYPE"]]
1148 type_corpse = world_db["ThingTypes"][type["TT_CORPSE_ID"]]
1149 if t["T_LIFEPOINTS"] > type["TT_LIFEPOINTS"] \
1150 and type_corpse["TT_TOOL"] == "food" \
1151 and type_corpse["TT_TOOLPOWER"] > eat_cost:
1155 def good_flee_target(m):
1156 own_corpse_id = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
1157 corpse_type = world_db["ThingTypes"][own_corpse_id]
1158 targetness = 0 if corpse_type["TT_TOOL"] != "food" \
1159 else corpse_type["TT_TOOLPOWER"]
1160 type = world_db["ThingTypes"][m["T_TYPE"]]
1161 if t["T_LIFEPOINTS"] < type["TT_LIFEPOINTS"] \
1162 and targetness > eat_vs_hunger_threshold(m["T_TYPE"]):
1167 if t["fovmap"] and "a" == filter:
1168 for id in world_db["Things"]:
1169 if animate_in_fov(world_db["Things"][id]):
1170 if good_attack_target(world_db["Things"][id]):
1172 elif t["fovmap"] and "f" == filter:
1173 for id in world_db["Things"]:
1174 if animate_in_fov(world_db["Things"][id]):
1175 if good_flee_target(world_db["Things"][id]):
1177 elif t["T_MEMMAP"] and "c" == filter:
1178 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
1179 for mt in t["T_MEMTHING"]:
1180 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1182 and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food" \
1183 and world_db["ThingTypes"][mt[0]]["TT_TOOLPOWER"] \
1188 def set_cells_passable_on_memmap_to_65534_on_scoremap():
1189 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1190 # ord_dot = ord(".")
1191 # memmap = t["T_MEMMAP"]
1192 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1193 # if ord_dot == memmap[i]]:
1194 # set_map_score(i, 65534) # i.e. 65535-1
1195 map = c_pointer_to_bytearray(t["T_MEMMAP"])
1196 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1197 raise RuntimeError("No score map allocated for "
1198 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1200 def init_score_map():
1201 test = libpr.init_score_map()
1203 raise RuntimeError("Malloc error in init_score_map().")
1205 ord_blank = ord(" ")
1206 set_cells_passable_on_memmap_to_65534_on_scoremap()
1208 for id in world_db["Things"]:
1209 if animate_in_fov(world_db["Things"][id]) \
1210 and good_attack_target(world_db["Things"][id]):
1211 set_map_score_at_thingpos(id, 0)
1213 for id in world_db["Things"]:
1214 if animate_in_fov(world_db["Things"][id]) \
1215 and good_flee_target(world_db["Things"][id]):
1216 set_map_score_at_thingpos(id, 0)
1218 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
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 if world_db["ThingTypes"][mt[0]]["TT_TOOLPOWER"]
1226 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1228 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1230 for id in world_db["Things"]:
1231 if animate_in_fov(world_db["Things"][id]):
1233 pos = world_db["Things"][id]["T_POSY"] \
1234 * world_db["MAP_LENGTH"] \
1235 + world_db["Things"][id]["T_POSX"]
1236 if 0 == get_map_score(pos):
1238 set_map_score_at_thingpos(id, 65535)
1240 def rand_target_dir(neighbors, cmp, dirs):
1243 for i in range(len(dirs)):
1244 if cmp == neighbors[i]:
1245 candidates.append(dirs[i])
1247 return candidates[rand.next() % n_candidates] if n_candidates else 0
1249 def get_neighbor_scores(dirs, eye_pos):
1251 if libpr.ready_neighbor_scores(eye_pos):
1252 raise RuntimeError("No score map allocated for " +
1253 "ready_neighbor_scores.()")
1254 for i in range(len(dirs)):
1255 scores.append(libpr.get_neighbor_score(i))
1258 def get_dir_from_neighbors():
1259 dir_to_target = False
1261 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1262 neighbors = get_neighbor_scores(dirs, eye_pos)
1263 minmax_start = 0 if "f" == filter else 65535 - 1
1264 minmax_neighbor = minmax_start
1265 for i in range(len(dirs)):
1266 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1267 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1268 or ("f" != filter and minmax_neighbor > neighbors[i]):
1269 minmax_neighbor = neighbors[i]
1270 if minmax_neighbor != minmax_start:
1271 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1273 distance = get_map_score(eye_pos)
1274 fear_distance = world_db["MAP_LENGTH"]
1275 if t["T_SATIATION"] < 0 and math.sqrt(-t["T_SATIATION"]) > 0:
1276 fear_distance = fear_distance / math.sqrt(-t["T_SATIATION"])
1278 if not dir_to_target:
1279 if attack_distance >= distance:
1280 dir_to_target = rand_target_dir(neighbors,
1282 elif fear_distance >= distance:
1283 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1285 world_db["ThingActions"][id]["TA_NAME"]
1288 elif dir_to_target and fear_distance < distance:
1290 return dir_to_target
1292 dir_to_target = False
1294 run_i = 9 + 1 if "s" == filter else 1
1295 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1298 mem_depth_c = b'9' if b' ' == mem_depth_c \
1299 else bytes([mem_depth_c[0] - 1])
1300 if libpr.dijkstra_map():
1301 raise RuntimeError("No score map allocated for dijkstra_map().")
1302 dir_to_target = get_dir_from_neighbors()
1303 libpr.free_score_map()
1304 if dir_to_target and str == type(dir_to_target):
1305 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1306 if world_db["ThingActions"][id]["TA_NAME"]
1308 t["T_ARGUMENT"] = ord(dir_to_target)
1309 return dir_to_target
1312 def standing_on_food(t):
1313 """Return True/False whether t is standing on healthy consumable."""
1314 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
1315 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1316 if not world_db["Things"][id]["carried"]
1317 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1318 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1319 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1320 ["TT_TOOL"] == "food"
1321 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1322 ["TT_TOOLPOWER"] > eat_cost]:
1327 def get_inventory_slot_to_consume(t):
1328 """Return invent. slot of healthiest consumable(if any healthy),else -1."""
1332 eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
1333 for id in t["T_CARRIES"]:
1334 type = world_db["Things"][id]["T_TYPE"]
1335 if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1336 and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
1337 nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1338 tmp_cmp = abs(t["T_SATIATION"] + nutvalue - eat_cost)
1339 if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1340 or tmp_cmp < cmp_food:
1348 """Determine next command/argment for actor t via AI algorithms."""
1349 # 7DRL add: Don't pick up or search things when inventory is full.
1350 if t == world_db["Things"][0]:
1352 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1353 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1354 if get_dir_to_target(t, "f"):
1355 if t == world_db["Things"][0]:
1358 sel = get_inventory_slot_to_consume(t)
1360 if t == world_db["Things"][0]:
1362 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1363 if world_db["ThingActions"][id]["TA_NAME"]
1365 t["T_ARGUMENT"] = sel
1366 elif standing_on_food(t):
1367 if t == world_db["Things"][0]:
1369 if (len(t["T_CARRIES"]) < # #
1370 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1371 if t == world_db["Things"][0]:
1373 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1374 if world_db["ThingActions"][id]["TA_NAME"]
1377 if t == world_db["Things"][0]:
1378 log("%AIMING_FOR_FOOD")
1379 going_to_known_food_spot = get_dir_to_target(t, "c")
1380 if not going_to_known_food_spot:
1381 if t == world_db["Things"][0]:
1382 log("%AIMING_FOR_WALKING_FOOD")
1383 aiming_for_walking_food = get_dir_to_target(t, "a")
1384 if not aiming_for_walking_food:
1385 if t == world_db["Things"][0]:
1387 get_dir_to_target(t, "s")
1391 """Run game world and its inhabitants until new player input expected."""
1393 whilebreaker = False
1394 while world_db["Things"][0]["T_LIFEPOINTS"]:
1395 proliferable_map = world_db["MAP"][:]
1396 for id in [id for id in world_db["Things"]
1397 if not world_db["Things"][id]["carried"]]:
1398 y = world_db["Things"][id]["T_POSY"]
1399 x = world_db["Things"][id]["T_POSX"]
1400 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1401 for id in [id for id in world_db["Things"]]: # Only what's from start!
1402 if not id in world_db["Things"] or \
1403 world_db["Things"][id]["carried"]: # May have been consumed or
1404 continue # picked up during turn …
1405 Thing = world_db["Things"][id]
1406 if Thing["T_LIFEPOINTS"]:
1407 if not Thing["T_COMMAND"]:
1408 update_map_memory(Thing)
1415 if Thing["T_LIFEPOINTS"]:
1416 Thing["T_PROGRESS"] += 1
1417 taid = [a for a in world_db["ThingActions"]
1418 if a == Thing["T_COMMAND"]][0]
1419 ThingAction = world_db["ThingActions"][taid]
1420 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1421 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1422 Thing["T_COMMAND"] = 0
1423 Thing["T_PROGRESS"] = 0
1424 thingproliferation(Thing, proliferable_map)
1427 world_db["TURN"] += 1
1430 def new_Thing(type, pos=(0, 0)):
1431 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1433 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1438 "T_PLAYERDROP": 0, # #
1446 "T_MEMDEPTHMAP": False,
1449 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1450 build_fov_map(thing)
1454 def id_setter(id, category, id_store=False, start_at_1=False):
1455 """Set ID of object of category to manipulate ID unused? Create new one.
1457 The ID is stored as id_store.id (if id_store is set). If the integer of the
1458 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1459 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1460 always returned when no new object is created, otherwise the new object's
1463 min = 0 if start_at_1 else -1
1465 id = integer_test(id, min)
1467 if id in world_db[category]:
1472 if (start_at_1 and 0 == id) \
1473 or ((not start_at_1) and (id < 0)):
1474 id = 0 if start_at_1 else -1
1477 if id not in world_db[category]:
1485 """Send PONG line to server output file."""
1486 strong_write(io_db["file_out"], "PONG\n")
1490 """Abort server process."""
1491 if None == opts.replay:
1492 if world_db["WORLD_ACTIVE"]:
1494 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1495 raise SystemExit("received QUIT command")
1498 def command_thingshere(str_y, str_x):
1499 """Write to out file list of Things known to player at coordinate y, x."""
1500 # 7DRL: terrain, too
1501 if world_db["WORLD_ACTIVE"]:
1502 y = integer_test(str_y, 0, 255)
1503 x = integer_test(str_x, 0, 255)
1504 length = world_db["MAP_LENGTH"]
1505 if None != y and None != x and y < length and x < length:
1506 pos = (y * world_db["MAP_LENGTH"]) + x
1507 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1508 pos = y * world_db["MAP_LENGTH"] + x; # #
1509 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1510 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1511 for id in world_db["Things"]
1512 if not world_db["Things"][id]["carried"]
1513 if world_db["Things"][id]["T_TYPE"] == tid
1514 if y == world_db["Things"][id]["T_POSY"]
1515 if x == world_db["Things"][id]["T_POSX"]]:
1516 type = world_db["Things"][id]["T_TYPE"]
1517 name = world_db["ThingTypes"][type]["TT_NAME"]
1518 strong_write(io_db["file_out"], name + "\n")
1520 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1521 for mt in world_db["Things"][0]["T_MEMTHING"]
1522 if mt[0] == tid if y == mt[1] if x == mt[2]]:
1523 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1524 strong_write(io_db["file_out"], name + "\n")
1525 if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"): # #
1526 name = "(terrain: SEA)" # #
1527 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."): # #
1528 name = "(terrain: EARTH)" # #
1529 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"): # #
1530 name = "(terrain: SOIL)" # #
1531 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"): # #
1532 name = "(terrain: TREE)" # #
1533 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"): # #
1534 name = "(terrain: WALL)" # #
1535 elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"): # #
1536 name = "(terrain: ALTAR)" # #
1539 strong_write(io_db["file_out"], name + "\n") # #
1540 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1542 print("Ignoring: Invalid map coordinates.")
1544 print("Ignoring: Command only works on existing worlds.")
1547 def play_commander(action, args=False):
1548 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1550 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1554 id = [x for x in world_db["ThingActions"]
1555 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1556 world_db["Things"][0]["T_COMMAND"] = id
1559 def set_command_and_argument_int(str_arg):
1560 val = integer_test(str_arg, 0, 255)
1562 world_db["Things"][0]["T_ARGUMENT"] = val
1565 def set_command_and_argument_movestring(str_arg):
1566 if str_arg in directions_db:
1567 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1570 print("Ignoring: Argument must be valid direction string.")
1572 if action == "move":
1573 return set_command_and_argument_movestring
1575 return set_command_and_argument_int
1580 def command_seedrandomness(seed_string):
1581 """Set rand seed to int(seed_string)."""
1582 val = integer_test(seed_string, 0, 4294967295)
1587 def command_makeworld(seed_string):
1588 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1590 Seed rand with seed. Do more only with a "wait" ThingAction and
1591 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1592 world_db["Things"] emptied, call make_map() and set
1593 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1594 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1595 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1596 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1600 # def free_pos(plant=False):
1601 def free_pos(plant=False): # #
1604 err = "Space to put thing on too hard to find. Map too small?"
1606 y = rand.next() % world_db["MAP_LENGTH"]
1607 x = rand.next() % world_db["MAP_LENGTH"]
1608 pos = y * world_db["MAP_LENGTH"] + x;
1610 and "." == chr(world_db["MAP"][pos])) \
1611 or ":" == chr(world_db["MAP"][pos]): # #
1615 raise SystemExit(err)
1616 # Replica of C code, wrongly ignores animatedness of new Thing.
1617 pos_clear = (0 == len([id for id in world_db["Things"]
1618 if world_db["Things"][id]["T_LIFEPOINTS"]
1619 if world_db["Things"][id]["T_POSY"] == y
1620 if world_db["Things"][id]["T_POSX"] == x]))
1625 val = integer_test(seed_string, 0, 4294967295)
1629 player_will_be_generated = False
1630 playertype = world_db["PLAYER_TYPE"]
1631 for ThingType in world_db["ThingTypes"]:
1632 if playertype == ThingType:
1633 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1634 player_will_be_generated = True
1636 if not player_will_be_generated:
1637 print("Ignoring: No player type with start number >0 defined.")
1640 for ThingAction in world_db["ThingActions"]:
1641 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1644 print("Ignoring: No thing action with name 'wait' defined.")
1646 for name in specials: # #
1647 if world_db[name] not in world_db["ThingTypes"]: # #
1648 print("Ignoring: No valid " + name + " set.") # #
1650 world_db["Things"] = {}
1652 world_db["WORLD_ACTIVE"] = 1
1653 world_db["TURN"] = 1
1654 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1655 id = id_setter(-1, "Things")
1656 world_db["Things"][id] = new_Thing(playertype, free_pos())
1657 if not world_db["Things"][0]["fovmap"]:
1658 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1659 world_db["Things"][0]["fovmap"] = empty_fovmap
1660 update_map_memory(world_db["Things"][0])
1661 for type in world_db["ThingTypes"]:
1662 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1663 if type != playertype:
1664 id = id_setter(-1, "Things")
1665 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"] # #
1666 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1667 strong_write(io_db["file_out"], "NEW_WORLD\n")
1671 def command_maplength(maplength_string):
1672 """Redefine map length. Invalidate map, therefore lose all things on it."""
1673 val = integer_test(maplength_string, 1, 256)
1675 world_db["MAP_LENGTH"] = val
1676 world_db["MAP"] = False
1677 set_world_inactive()
1678 world_db["Things"] = {}
1679 libpr.set_maplength(val)
1682 def command_worldactive(worldactive_string):
1683 """Toggle world_db["WORLD_ACTIVE"] if possible.
1685 An active world can always be set inactive. An inactive world can only be
1686 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1687 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1688 Also call log_help().
1690 # 7DRL: altar must be on map, and specials must be set for active world.
1691 val = integer_test(worldactive_string, 0, 1)
1693 if 0 != world_db["WORLD_ACTIVE"]:
1695 set_world_inactive()
1697 print("World already active.")
1698 elif 0 == world_db["WORLD_ACTIVE"]:
1700 for ThingAction in world_db["ThingActions"]:
1701 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1704 player_exists = False
1705 for Thing in world_db["Things"]:
1707 player_exists = True
1709 specials_set = True # #
1710 for name in specials: # #
1711 if world_db[name] not in world_db["ThingTypes"]: # #
1712 specials_set = False # #
1713 altar_found = False # #
1714 if world_db["MAP"]: # #
1715 pos = world_db["MAP"].find(b'_') # #
1717 y = int(pos / world_db["MAP_LENGTH"]) # #
1718 x = pos % world_db["MAP_LENGTH"] # #
1719 world_db["altar"] = (y, x) # #
1720 altar_found = True # #
1721 if wait_exists and player_exists and world_db["MAP"] \
1722 and specials_set: # #
1723 for id in world_db["Things"]:
1724 if world_db["Things"][id]["T_LIFEPOINTS"]:
1725 build_fov_map(world_db["Things"][id])
1727 update_map_memory(world_db["Things"][id], False)
1728 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1729 empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1730 world_db["Things"][0]["fovmap"] = empty_fovmap
1731 world_db["WORLD_ACTIVE"] = 1
1734 print("Ignoring: Not all conditions for world activation met.")
1737 def specialtypesetter(name): # #
1738 """Setter world_db[name], deactivating world if set int no ThingType."""
1739 def helper(str_int):
1740 val = integer_test(str_int, 0)
1742 world_db[name] = val
1743 if world_db["WORLD_ACTIVE"] \
1744 and world_db[name] not in world_db["ThingTypes"]:
1745 world_db["WORLD_ACTIVE"] = 0
1746 print(name + " fits no known ThingType, deactivating world.")
1750 def test_for_id_maker(object, category):
1751 """Return decorator testing for object having "id" attribute."""
1754 if hasattr(object, "id"):
1757 print("Ignoring: No " + category +
1758 " defined to manipulate yet.")
1763 def command_tid(id_string):
1764 """Set ID of Thing to manipulate. ID unused? Create new one.
1766 Default new Thing's type to the first available ThingType, others: zero.
1768 id = id_setter(id_string, "Things", command_tid)
1770 if world_db["ThingTypes"] == {}:
1771 print("Ignoring: No ThingType to settle new Thing in.")
1773 type = list(world_db["ThingTypes"].keys())[0]
1774 world_db["Things"][id] = new_Thing(type)
1777 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1781 def command_tcommand(str_int):
1782 """Set T_COMMAND of selected Thing."""
1783 val = integer_test(str_int, 0)
1785 if 0 == val or val in world_db["ThingActions"]:
1786 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1788 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1792 def command_ttype(str_int):
1793 """Set T_TYPE of selected Thing."""
1794 val = integer_test(str_int, 0)
1796 if val in world_db["ThingTypes"]:
1797 world_db["Things"][command_tid.id]["T_TYPE"] = val
1799 print("Ignoring: ThingType ID belongs to no known ThingType.")
1803 def command_tcarries(str_int):
1804 """Append int(str_int) to T_CARRIES of selected Thing.
1806 The ID int(str_int) must not be of the selected Thing, and must belong to a
1807 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1809 val = integer_test(str_int, 0)
1811 if val == command_tid.id:
1812 print("Ignoring: Thing cannot carry itself.")
1813 elif val in world_db["Things"] \
1814 and not world_db["Things"][val]["carried"]:
1815 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1816 world_db["Things"][val]["carried"] = True
1818 print("Ignoring: Thing not available for carrying.")
1819 # Note that the whole carrying structure is different from the C version:
1820 # Carried-ness is marked by a "carried" flag, not by Things containing
1821 # Things internally.
1825 def command_tmemthing(str_t, str_y, str_x):
1826 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1828 The type must fit to an existing ThingType, and the position into the map.
1830 type = integer_test(str_t, 0)
1831 posy = integer_test(str_y, 0, 255)
1832 posx = integer_test(str_x, 0, 255)
1833 if None != type and None != posy and None != posx:
1834 if type not in world_db["ThingTypes"] \
1835 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1836 print("Ignoring: Illegal value for thing type or position.")
1838 memthing = (type, posy, posx)
1839 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1842 def setter_map(maptype):
1843 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1845 If no map of maptype exists yet, initialize it with ' ' bytes first.
1848 def valid_map_line(str_int, mapline):
1849 val = integer_test(str_int, 0, 255)
1851 if val >= world_db["MAP_LENGTH"]:
1852 print("Illegal value for map line number.")
1853 elif len(mapline) != world_db["MAP_LENGTH"]:
1854 print("Map line length is unequal map width.")
1859 def nonThingMap_helper(str_int, mapline):
1860 val = valid_map_line(str_int, mapline)
1862 length = world_db["MAP_LENGTH"]
1863 if not world_db["MAP"]:
1864 map = bytearray(b' ' * (length ** 2))
1866 map = world_db["MAP"]
1867 map[val * length:(val * length) + length] = mapline.encode()
1868 if not world_db["MAP"]:
1869 world_db["MAP"] = map
1872 def ThingMap_helper(str_int, mapline):
1873 val = valid_map_line(str_int, mapline)
1875 length = world_db["MAP_LENGTH"]
1876 if not world_db["Things"][command_tid.id][maptype]:
1877 map = bytearray(b' ' * (length ** 2))
1879 map = world_db["Things"][command_tid.id][maptype]
1880 map[val * length:(val * length) + length] = mapline.encode()
1881 if not world_db["Things"][command_tid.id][maptype]:
1882 world_db["Things"][command_tid.id][maptype] = map
1884 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1887 def setter_tpos(axis):
1888 """Generate setter for T_POSX or T_POSY of selected Thing.
1890 If world is active, rebuilds animate things' fovmap, player's memory map.
1893 def helper(str_int):
1894 val = integer_test(str_int, 0, 255)
1896 if val < world_db["MAP_LENGTH"]:
1897 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1898 if world_db["WORLD_ACTIVE"] \
1899 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1900 build_fov_map(world_db["Things"][command_tid.id])
1901 if 0 == command_tid.id:
1902 update_map_memory(world_db["Things"][command_tid.id])
1904 print("Ignoring: Position is outside of map.")
1908 def command_ttid(id_string):
1909 """Set ID of ThingType to manipulate. ID unused? Create new one.
1911 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1914 id = id_setter(id_string, "ThingTypes", command_ttid)
1916 world_db["ThingTypes"][id] = {
1917 "TT_NAME": "(none)",
1920 "TT_PROLIFERATE": 0,
1921 "TT_START_NUMBER": 0,
1922 "TT_STORAGE": 0, # #
1929 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1933 def command_ttname(name):
1934 """Set TT_NAME of selected ThingType."""
1935 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1939 def command_tttool(name):
1940 """Set TT_TOOL of selected ThingType."""
1941 world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1945 def command_ttsymbol(char):
1946 """Set TT_SYMBOL of selected ThingType. """
1948 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1950 print("Ignoring: Argument must be single character.")
1954 def command_ttcorpseid(str_int):
1955 """Set TT_CORPSE_ID of selected ThingType."""
1956 val = integer_test(str_int, 0)
1958 if val in world_db["ThingTypes"]:
1959 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1961 print("Ignoring: Corpse ID belongs to no known ThignType.")
1964 def command_taid(id_string):
1965 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1967 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1969 id = id_setter(id_string, "ThingActions", command_taid, True)
1971 world_db["ThingActions"][id] = {
1977 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1980 @test_ThingAction_id
1981 def command_taname(name):
1982 """Set TA_NAME of selected ThingAction.
1984 The name must match a valid thing action function. If after the name
1985 setting no ThingAction with name "wait" remains, call set_world_inactive().
1987 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1988 or name == "pick_up":
1989 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1990 if 1 == world_db["WORLD_ACTIVE"]:
1991 wait_defined = False
1992 for id in world_db["ThingActions"]:
1993 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1996 if not wait_defined:
1997 set_world_inactive()
1999 print("Ignoring: Invalid action name.")
2000 # In contrast to the original,naming won't map a function to a ThingAction.
2004 """Call ai() on player Thing, then turn_over()."""
2005 ai(world_db["Things"][0])
2009 """Commands database.
2011 Map command start tokens to ([0]) number of expected command arguments, ([1])
2012 the command's meta-ness (i.e. is it to be written to the record file, is it to
2013 be ignored in replay mode if read from server input file), and ([2]) a function
2017 "QUIT": (0, True, command_quit),
2018 "PING": (0, True, command_ping),
2019 "THINGS_HERE": (2, True, command_thingshere),
2020 "MAKE_WORLD": (1, False, command_makeworld),
2021 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
2022 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
2023 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
2024 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
2025 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
2026 "MAP_LENGTH": (1, False, command_maplength),
2027 "WORLD_ACTIVE": (1, False, command_worldactive),
2028 "MAP": (2, False, setter_map("MAP")),
2029 "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)), # #
2030 "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")), # #
2031 "PLANT_0": (1, False, specialtypesetter("PLANT_0")), # #
2032 "PLANT_1": (1, False, specialtypesetter("PLANT_1")), # #
2033 "LUMBER": (1, False, specialtypesetter("LUMBER")), # #
2034 "TOOL_0": (1, False, specialtypesetter("TOOL_0")), # #
2035 "EMPATHY": (1, False, setter(None, "EMPATHY", 0, 1)), # #
2036 "TA_ID": (1, False, command_taid),
2037 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
2038 "TA_NAME": (1, False, command_taname),
2039 "TT_ID": (1, False, command_ttid),
2040 "TT_NAME": (1, False, command_ttname),
2041 "TT_TOOL": (1, False, command_tttool),
2042 "TT_SYMBOL": (1, False, command_ttsymbol),
2043 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
2044 "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
2045 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
2047 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2049 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2050 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
2051 "T_ID": (1, False, command_tid),
2052 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2053 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2054 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2055 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2056 "T_COMMAND": (1, False, command_tcommand),
2057 "T_TYPE": (1, False, command_ttype),
2058 "T_CARRIES": (1, False, command_tcarries),
2059 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2060 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2061 "T_MEMTHING": (3, False, command_tmemthing),
2062 "T_POSY": (1, False, setter_tpos("Y")),
2063 "T_POSX": (1, False, setter_tpos("X")),
2064 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
2065 "wait": (0, False, play_commander("wait")),
2066 "move": (1, False, play_commander("move")),
2067 "pick_up": (0, False, play_commander("pick_up")),
2068 "drop": (1, False, play_commander("drop", True)),
2069 "use": (1, False, play_commander("use", True)),
2070 "ai": (0, False, command_ai)
2072 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2075 """World state database. With sane default values. (Randomness is in rand.)"""
2084 "FAVOR_STAGE": 0, # #
2097 """Special type settings."""
2098 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"] # #
2100 """Mapping of direction names to internal direction chars."""
2101 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2102 "west": "s", "north-west": "w", "north-east": "e"}
2104 """File IO database."""
2106 "path_save": "save",
2107 "path_record": "record_save",
2108 "path_worldconf": "confserver/world",
2109 "path_server": "server/",
2110 "path_in": "server/in",
2111 "path_out": "server/out",
2112 "path_worldstate": "server/worldstate",
2113 "tmp_suffix": "_tmp",
2114 "kicked_by_rival": False,
2115 "worldstate_updateable": False
2120 libpr = prep_library()
2121 rand = RandomnessIO()
2122 opts = parse_command_line_arguments()
2124 io_db["path_save"] = opts.savefile
2125 io_db["path_record"] = "record_" + opts.savefile
2128 io_db["verbose"] = True
2129 if None != opts.replay:
2133 except SystemExit as exit:
2134 print("ABORTING: " + exit.args[0])
2136 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")