3 # This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
4 # or any later version. For details on its copyright, license, and warranties,
5 # see the file NOTICE in the root directory of the PlomRogue source package.
19 """"Interface to libplomrogue's pseudo-randomness generator."""
21 def set_seed(self, seed):
22 libpr.seed_rrand(1, seed)
25 return libpr.seed_rrand(0, 0)
30 seed = property(get_seed, set_seed)
34 """Prepare ctypes library at ./libplomrogue.so"""
35 libpath = ("./libplomrogue.so")
36 if not os.access(libpath, os.F_OK):
37 raise SystemExit("No library " + libpath + ", run ./redo first?")
38 libpr = ctypes.cdll.LoadLibrary(libpath)
39 libpr.seed_rrand.restype = ctypes.c_uint32
43 def c_pointer_to_bytearray(ba):
44 """Return C char * pointer to ba."""
45 type = ctypes.c_char * len(ba)
46 return type.from_buffer(ba)
49 def strong_write(file, string):
50 """Apply write(string), then flush()."""
55 def setup_server_io():
56 """Fill IO files DB with proper file( path)s. Write process IO test string.
58 Ensure IO files directory at server/. Remove any old input file if found.
59 Set up new input file for reading, and new output file for writing. Start
60 output file with process hash line of format PID + " " + floated UNIX time
61 (io_db["teststring"]). Raise SystemExit if file is found at path of either
62 record or save file plus io_db["tmp_suffix"].
64 def detect_atomic_leftover(path, tmp_suffix):
65 path_tmp = path + tmp_suffix
66 msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
67 "aborted previous attempt to write '" + path + "'. Aborting " \
68 "until matter is resolved by removing it from its current path."
69 if os.access(path_tmp, os.F_OK):
71 io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
72 io_db["save_wait"] = 0
73 io_db["verbose"] = False
74 io_db["record_chunk"] = ""
75 os.makedirs(io_db["path_server"], exist_ok=True)
76 io_db["file_out"] = open(io_db["path_out"], "w")
77 strong_write(io_db["file_out"], io_db["teststring"] + "\n")
78 if os.access(io_db["path_in"], os.F_OK):
79 os.remove(io_db["path_in"])
80 io_db["file_in"] = open(io_db["path_in"], "w")
81 io_db["file_in"].close()
82 io_db["file_in"] = open(io_db["path_in"], "r")
83 detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
84 detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
87 def cleanup_server_io():
88 """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
89 def helper(file_key, path_key):
91 io_db[file_key].close()
92 if not io_db["kicked_by_rival"] \
93 and os.access(io_db[path_key], os.F_OK):
94 os.remove(io_db[path_key])
95 helper("file_in", "path_in")
96 helper("file_out", "path_out")
97 helper("file_worldstate", "path_worldstate")
98 if "file_record" in io_db:
99 io_db["file_record"].close()
102 def obey(command, prefix, replay=False, do_record=False):
103 """Call function from commands_db mapped to command's first token.
105 Tokenize command string with shlex.split(comments=True). If replay is set,
106 a non-meta command from the commands_db merely triggers obey() on the next
107 command from the records file. If not, non-meta commands set
108 io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
109 do_record is set, are recorded to io_db["record_chunk"], and save_world()
110 is called (and io_db["record_chunk"] written) if 15 seconds have passed
111 since the last time it was called. The prefix string is inserted into the
112 server's input message between its beginning 'input ' and ':'. All activity
113 is preceded by a server_test() call. Commands that start with a lowercase
114 letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
118 print("input " + prefix + ": " + command)
120 tokens = shlex.split(command, comments=True)
121 except ValueError as err:
122 print("Can't tokenize command string: " + str(err) + ".")
124 if len(tokens) > 0 and tokens[0] in commands_db \
125 and len(tokens) == commands_db[tokens[0]][0] + 1:
126 if commands_db[tokens[0]][1]:
127 commands_db[tokens[0]][2](*tokens[1:])
128 elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
129 print("Ignoring lowercase-starting commands when world inactive.")
131 print("Due to replay mode, reading command as 'go on in record'.")
132 line = io_db["file_record"].readline()
134 obey(line.rstrip(), io_db["file_record"].prefix
135 + str(io_db["file_record"].line_n))
136 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
138 print("Reached end of record file.")
140 commands_db[tokens[0]][2](*tokens[1:])
142 io_db["record_chunk"] += command + "\n"
143 if time.time() > io_db["save_wait"] + 15:
144 atomic_write(io_db["path_record"], io_db["record_chunk"],
146 if world_db["WORLD_ACTIVE"]:
148 io_db["record_chunk"] = ""
149 io_db["save_wait"] = time.time()
150 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
151 elif 0 != len(tokens):
152 print("Invalid command/argument, or bad number of tokens.")
155 def atomic_write(path, text, do_append=False, delete=True):
156 """Atomic write of text to file at path, appended if do_append is set."""
157 path_tmp = path + io_db["tmp_suffix"]
161 if os.access(path, os.F_OK):
162 shutil.copyfile(path, path_tmp)
163 file = open(path_tmp, mode)
164 strong_write(file, text)
166 if delete and os.access(path, os.F_OK):
168 os.rename(path_tmp, path)
172 """Save all commands needed to reconstruct current world state."""
175 string = string.replace("\u005C", '\u005C\u005C')
176 return '"' + string.replace('"', '\u005C"') + '"'
181 if key == "MAP" or world_db["Things"][id][key]:
182 map = world_db["MAP"] if key == "MAP" \
183 else world_db["Things"][id][key]
184 length = world_db["MAP_LENGTH"]
185 for i in range(length):
186 line = map[i * length:(i * length) + length].decode()
187 string = string + key + " " + str(i) + " " + quote(line) \
194 for memthing in world_db["Things"][id]["T_MEMTHING"]:
195 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
196 str(memthing[1]) + " " + str(memthing[2]) + "\n"
199 def helper(category, id_string, special_keys={}):
201 for id in world_db[category]:
202 string = string + id_string + " " + str(id) + "\n"
203 for key in world_db[category][id]:
204 if not key in special_keys:
205 x = world_db[category][id][key]
206 argument = quote(x) if str == type(x) else str(x)
207 string = string + key + " " + argument + "\n"
208 elif special_keys[key]:
209 string = string + special_keys[key](id)
214 if dict != type(world_db[key]) \
215 and key != "MAP" and key != "WORLD_ACTIVE":
216 string = string + key + " " + str(world_db[key]) + "\n"
217 string = string + mapsetter("MAP")()
218 string = string + helper("ThingActions", "TA_ID")
219 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
220 for id in world_db["ThingTypes"]:
221 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
222 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
223 string = string + helper("Things", "T_ID",
224 {"T_CARRIES": False, "carried": False,
225 "T_MEMMAP": mapsetter("T_MEMMAP"),
226 "T_MEMTHING": memthing, "fovmap": False,
227 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
228 for id in world_db["Things"]:
229 if [] != world_db["Things"][id]["T_CARRIES"]:
230 string = string + "T_ID " + str(id) + "\n"
231 for carried_id in world_db["Things"][id]["T_CARRIES"]:
232 string = string + "T_CARRIES " + str(carried_id) + "\n"
233 string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
234 "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
235 atomic_write(io_db["path_save"], string)
238 def obey_lines_in_file(path, name, do_record=False):
239 """Call obey() on each line of path's file, use name in input prefix."""
240 file = open(path, "r")
242 for line in file.readlines():
243 obey(line.rstrip(), name + "file line " + str(line_n),
249 def parse_command_line_arguments():
250 """Return settings values read from command line arguments."""
251 parser = argparse.ArgumentParser()
252 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
254 parser.add_argument('-l', nargs="?", const="save", dest='savefile',
256 parser.add_argument('-v', dest='verbose', action='store_true')
257 opts, unknown = parser.parse_known_args()
262 """Ensure valid server out file belonging to current process.
264 This is done by comparing io_db["teststring"] to what's found at the start
265 of the current file at io_db["path_out"]. On failure, set
266 io_db["kicked_by_rival"] and raise SystemExit.
268 if not os.access(io_db["path_out"], os.F_OK):
269 raise SystemExit("Server output file has disappeared.")
270 file = open(io_db["path_out"], "r")
271 test = file.readline().rstrip("\n")
273 if test != io_db["teststring"]:
274 io_db["kicked_by_rival"] = True
275 msg = "Server test string in server output file does not match. This" \
276 " indicates that the current server process has been " \
277 "superseded by another one."
278 raise SystemExit(msg)
282 """Return next newline-delimited command from server in file.
284 Keep building return string until a newline is encountered. Pause between
285 unsuccessful reads, and after too much waiting, run server_test().
287 wait_on_fail = 0.03333
292 add = io_db["file_in"].readline()
294 command = command + add
295 if len(command) > 0 and "\n" == command[-1]:
296 command = command[:-1]
299 time.sleep(wait_on_fail)
300 if now + max_wait < time.time():
306 def try_worldstate_update():
307 """Write worldstate file if io_db["worldstate_updateable"] is set."""
308 if io_db["worldstate_updateable"]:
310 def draw_visible_Things(map, run):
311 for id in world_db["Things"]:
312 type = world_db["Things"][id]["T_TYPE"]
313 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
314 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
315 if (0 == run and not consumable and not alive) \
316 or (1 == run and consumable and not alive) \
317 or (2 == run and alive):
318 y = world_db["Things"][id]["T_POSY"]
319 x = world_db["Things"][id]["T_POSX"]
320 fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
321 if 'v' == chr(fovflag):
322 c = world_db["ThingTypes"][type]["TT_SYMBOL"]
323 map[(y * length) + x] = ord(c)
325 def write_map(string, map):
326 for i in range(length):
327 line = map[i * length:(i * length) + length].decode()
328 string = string + line + "\n"
332 if [] == world_db["Things"][0]["T_CARRIES"]:
333 inventory = "(none)\n"
335 for id in world_db["Things"][0]["T_CARRIES"]:
336 type_id = world_db["Things"][id]["T_TYPE"]
337 name = world_db["ThingTypes"][type_id]["TT_NAME"]
338 inventory = inventory + name + "\n"
339 # # 7DRL additions: GOD_MOOD, GOD_FAVOR
340 string = str(world_db["TURN"]) + "\n" + \
341 str(world_db["GOD_MOOD"]) + "\n" + \
342 str(world_db["GOD_FAVOR"]) + "\n" + \
343 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
344 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
345 inventory + "%\n" + \
346 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
347 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
348 str(world_db["MAP_LENGTH"]) + "\n"
349 length = world_db["MAP_LENGTH"]
350 fov = bytearray(b' ' * (length ** 2))
351 for pos in range(length ** 2):
352 if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
353 fov[pos] = world_db["MAP"][pos]
355 draw_visible_Things(fov, i)
356 string = write_map(string, fov)
357 mem = world_db["Things"][0]["T_MEMMAP"][:]
359 for mt in world_db["Things"][0]["T_MEMTHING"]:
360 consumable = world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]
361 if (i == 0 and not consumable) or (i == 1 and consumable):
362 c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
363 mem[(mt[1] * length) + mt[2]] = ord(c)
364 string = write_map(string, mem)
365 atomic_write(io_db["path_worldstate"], string, delete=False)
366 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
367 io_db["worldstate_updateable"] = False
371 """Replay game from record file.
373 Use opts.replay as breakpoint turn to which to replay automatically before
374 switching to manual input by non-meta commands in server input file
375 triggering further reads of record file. Ensure opts.replay is at least 1.
376 Run try_worldstate_update() before each interactive obey()/read_command().
380 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
381 " (if so late a turn is to be found).")
382 if not os.access(io_db["path_record"], os.F_OK):
383 raise SystemExit("No record file found to replay.")
384 io_db["file_record"] = open(io_db["path_record"], "r")
385 io_db["file_record"].prefix = "record file line "
386 io_db["file_record"].line_n = 1
387 while world_db["TURN"] < opts.replay:
388 line = io_db["file_record"].readline()
391 obey(line.rstrip(), io_db["file_record"].prefix
392 + str(io_db["file_record"].line_n))
393 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
395 try_worldstate_update()
396 obey(read_command(), "in file", replay=True)
400 """Play game by server input file commands. Before, load save file found.
402 If no save file is found, a new world is generated from the commands in the
403 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
404 command and all that follow via the server input file. Run
405 try_worldstate_update() before each interactive obey()/read_command().
407 if os.access(io_db["path_save"], os.F_OK):
408 obey_lines_in_file(io_db["path_save"], "save")
410 if not os.access(io_db["path_worldconf"], os.F_OK):
411 msg = "No world config file from which to start a new world."
412 raise SystemExit(msg)
413 obey_lines_in_file(io_db["path_worldconf"], "world config ",
415 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
417 try_worldstate_update()
418 obey(read_command(), "in file", do_record=True)
422 """(Re-)make island map.
424 Let "~" represent water, "." land, "X" trees: Build island shape randomly,
425 start with one land cell in the middle, then go into cycle of repeatedly
426 selecting a random sea cell and transforming it into land if it is neighbor
427 to land. The cycle ends when a land cell is due to be created at the map's
428 border. Then put some trees on the map (TODO: more precise algorithm desc).
431 def is_neighbor(coordinates, type):
434 length = world_db["MAP_LENGTH"]
436 diag_west = x + (ind > 0)
437 diag_east = x + (ind < (length - 1))
438 pos = (y * length) + x
439 if (y > 0 and diag_east
440 and type == chr(world_db["MAP"][pos - length + ind])) \
442 and type == chr(world_db["MAP"][pos + 1])) \
443 or (y < (length - 1) and diag_east
444 and type == chr(world_db["MAP"][pos + length + ind])) \
445 or (y > 0 and diag_west
446 and type == chr(world_db["MAP"][pos - length - (not ind)])) \
448 and type == chr(world_db["MAP"][pos - 1])) \
449 or (y < (length - 1) and diag_west
450 and type == chr(world_db["MAP"][pos + length - (not ind)])):
454 world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
455 length = world_db["MAP_LENGTH"]
456 add_half_width = (not (length % 2)) * int(length / 2)
457 world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
459 y = rand.next() % length
460 x = rand.next() % length
461 pos = (y * length) + x
462 if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
463 if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
465 world_db["MAP"][pos] = ord(".")
466 n_trees = int((length ** 2) / 16)
468 while (i_trees <= n_trees):
469 single_allowed = rand.next() % 32
470 y = rand.next() % length
471 x = rand.next() % length
472 pos = (y * length) + x
473 if "." == chr(world_db["MAP"][pos]) \
474 and ((not single_allowed) or is_neighbor((y, x), "X")):
475 world_db["MAP"][pos] = ord("X")
477 # This all-too-precise replica of the original C code misses iter_limit().
480 def update_map_memory(t, age_map=True):
481 """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
482 def age_some_memdepthmap_on_nonfov_cells():
483 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
487 # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
488 # if not ord_v == t["fovmap"][pos]
489 # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
490 # if ord_9 > t["T_MEMDEPTHMAP"][pos]
491 # if not rand.next() % (2 **
492 # (t["T_MEMDEPTHMAP"][pos] - 48))]:
493 # t["T_MEMDEPTHMAP"][pos] += 1
494 memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
495 fovmap = c_pointer_to_bytearray(t["fovmap"])
496 libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
497 if not t["T_MEMMAP"]:
498 t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
499 if not t["T_MEMDEPTHMAP"]:
500 t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
504 for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
505 if ord_v == t["fovmap"][pos]]:
506 t["T_MEMDEPTHMAP"][pos] = ord_0
507 if ord_space == t["T_MEMMAP"][pos]:
508 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
510 age_some_memdepthmap_on_nonfov_cells()
511 t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
512 if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
514 for id in [id for id in world_db["Things"]
515 if not world_db["Things"][id]["carried"]]:
516 type = world_db["Things"][id]["T_TYPE"]
517 if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
518 y = world_db["Things"][id]["T_POSY"]
519 x = world_db["Things"][id]["T_POSX"]
520 if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
521 t["T_MEMTHING"].append((type, y, x))
524 def set_world_inactive():
525 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
527 if os.access(io_db["path_worldstate"], os.F_OK):
528 os.remove(io_db["path_worldstate"])
529 world_db["WORLD_ACTIVE"] = 0
532 def integer_test(val_string, min, max=None):
533 """Return val_string if possible integer >= min and <= max, else None."""
535 val = int(val_string)
536 if val < min or (max is not None and val > max):
540 msg = "Ignoring: Please use integer >= " + str(min)
542 msg += " and <= " + str(max)
548 def setter(category, key, min, max=None):
549 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
552 val = integer_test(val_string, min, max)
556 if category == "Thing":
557 id_store = command_tid
558 decorator = test_Thing_id
559 elif category == "ThingType":
560 id_store = command_ttid
561 decorator = test_ThingType_id
562 elif category == "ThingAction":
563 id_store = command_taid
564 decorator = test_ThingAction_id
568 val = integer_test(val_string, min, max)
570 world_db[category + "s"][id_store.id][key] = val
574 def build_fov_map(t):
575 """Build Thing's FOV map."""
576 t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
577 fovmap = c_pointer_to_bytearray(t["fovmap"])
578 map = c_pointer_to_bytearray(world_db["MAP"])
579 if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
580 raise RuntimeError("Malloc error in build_fov_Map().")
583 def decrement_lifepoints(t):
584 """Decrement t's lifepoints by 1, and if to zero, corpse it.
586 If t is the player avatar, only blank its fovmap, so that the client may
587 still display memory data. On non-player things, erase fovmap and memory.
588 Dying actors drop all their things.
590 # # 7DRL: also decrements God's mood; deaths heavily so
591 # # 7DRL: return 1 if death, else 0
592 t["T_LIFEPOINTS"] -= 1
593 world_db["GOD_MOOD"] -= 1 # #
594 if 0 == t["T_LIFEPOINTS"]:
595 sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] # #
596 world_db["GOD_MOOD"] -= sadness # #
597 for id in t["T_CARRIES"]:
598 t["T_CARRIES"].remove(id)
599 world_db["Things"][id]["T_POSY"] = t["T_POSY"]
600 world_db["Things"][id]["T_POSX"] = t["T_POSX"]
601 world_db["Things"][id]["carried"] = False
602 t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
603 if world_db["Things"][0] == t:
604 t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
605 strong_write(io_db["file_out"], "LOG You die.\n")
608 t["T_MEMMAP"] = False
609 t["T_MEMDEPTHMAP"] = False
615 def add_gods_favor(i): # #
616 """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
617 def favor_multiplier(i):
619 threshold = math.e * x
620 mood = world_db["GOD_MOOD"]
623 i = i * math.log(mood / x)
624 elif -mood > threshold:
625 i = i / math.log(-mood / x)
627 if -mood > threshold:
628 i = i * math.log(-mood / x)
630 i = i / math.log(mood / x)
632 world_db["GOD_FAVOR"] += favor_multiplier(i)
635 def mv_yx_in_dir_legal(dir, y, x):
636 """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
637 dir_c = dir.encode("ascii")[0]
638 test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
640 raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
641 return (test, libpr.result_y(), libpr.result_x())
645 """Make t do nothing (but loudly, if player avatar)."""
646 if t == world_db["Things"][0]:
647 strong_write(io_db["file_out"], "LOG You wait.\n")
651 """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
652 # # 7DRL: Player wounding (worse: killing) others will lower God's favor.
654 move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
655 t["T_POSY"], t["T_POSX"])
656 if 1 == move_result[0]:
657 pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
658 passable = "." == chr(world_db["MAP"][pos]) or \
659 ":" == chr(world_db["MAP"][pos]) # #
660 hitted = [id for id in world_db["Things"]
661 if world_db["Things"][id] != t
662 if world_db["Things"][id]["T_LIFEPOINTS"]
663 if world_db["Things"][id]["T_POSY"] == move_result[1]
664 if world_db["Things"][id]["T_POSX"] == move_result[2]]
667 if t == world_db["Things"][0]:
668 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
669 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
670 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
672 add_gods_favor(-1) # #
674 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
675 strong_write(io_db["file_out"], "LOG " + hitter_name +
677 test = decrement_lifepoints(world_db["Things"][hit_id]) # #(test=)
678 if test and t == world_db["Things"][0]: # #
679 add_gods_favor(-test) # #
681 dir = [dir for dir in directions_db
682 if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
684 t["T_POSY"] = move_result[1]
685 t["T_POSX"] = move_result[2]
686 for id in t["T_CARRIES"]:
687 world_db["Things"][id]["T_POSY"] = move_result[1]
688 world_db["Things"][id]["T_POSX"] = move_result[2]
690 if t == world_db["Things"][0]:
691 strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
692 elif t == world_db["Things"][0]:
693 strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
696 def actor_pick_up(t):
697 """Make t pick up (topmost?) Thing from ground into inventory."""
698 # Topmostness is actually not defined so far. Picks most nutritious Thing.
699 # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
700 used_slots = len(t["T_CARRIES"]) # #
701 if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
702 ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
703 if not world_db["Things"][id]["carried"]
704 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
705 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
710 type = world_db["Things"][id]["T_TYPE"]
711 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
712 nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
714 world_db["Things"][highest_id]["carried"] = True
715 if (t != world_db["Things"][0] and # #
716 world_db["Things"][highest_id]["T_PLAYERDROP"]): # #
717 x = world_db["Things"][highest_id]["T_TYPE"]
718 score = world_db["ThingTypes"][x]["TT_CONSUMABLE"] / 32 # #
719 add_gods_favor(score) # #
720 world_db["Things"][highest_id]["T_PLAYERDROP"] = 0 # #
721 t["T_CARRIES"].append(highest_id)
722 if t == world_db["Things"][0]:
723 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
724 elif t == world_db["Things"][0]:
725 err = "You try to pick up an object, but there is none."
726 strong_write(io_db["file_out"], "LOG " + err + "\n")
727 elif t == world_db["Things"][0]: # #
728 strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
729 "No storage room to carry more.\n") # #
733 """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
734 # TODO: Handle case where T_ARGUMENT matches nothing.
735 if len(t["T_CARRIES"]):
736 id = t["T_CARRIES"][t["T_ARGUMENT"]]
737 t["T_CARRIES"].remove(id)
738 world_db["Things"][id]["carried"] = False
739 if t == world_db["Things"][0]:
740 strong_write(io_db["file_out"], "LOG You drop an object.\n")
741 world_db["Things"][id]["T_PLAYERDROP"] = 1 # #
742 elif t == world_db["Things"][0]:
743 err = "You try to drop an object, but you own none."
744 strong_write(io_db["file_out"], "LOG " + err + "\n")
748 """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
749 # TODO: Handle case where T_ARGUMENT matches nothing.
750 if len(t["T_CARRIES"]):
751 id = t["T_CARRIES"][t["T_ARGUMENT"]]
752 type = world_db["Things"][id]["T_TYPE"]
753 if world_db["ThingTypes"][type]["TT_CONSUMABLE"]:
754 t["T_CARRIES"].remove(id)
755 del world_db["Things"][id]
756 t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_CONSUMABLE"]
757 if t == world_db["Things"][0]:
758 strong_write(io_db["file_out"],
759 "LOG You consume this object.\n")
760 elif t == world_db["Things"][0]:
761 strong_write(io_db["file_out"],
762 "LOG You try to use this object, but fail.\n")
763 elif t == world_db["Things"][0]:
764 strong_write(io_db["file_out"],
765 "LOG You try to use an object, but you own none.\n")
768 def thingproliferation(t, prol_map):
769 """To chance of 1/TT_PROLIFERATE,create t offspring in open neighbor cell.
771 Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
772 marked "." in prol_map. If there are several map cell candidates, one is
775 # # 7DRL: success increments God's mood
776 prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
777 if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
779 for dir in [directions_db[key] for key in directions_db]:
780 mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
781 if mv_result[0] and ord(".") == prol_map[mv_result[1]
782 * world_db["MAP_LENGTH"]
784 candidates.append((mv_result[1], mv_result[2]))
786 i = rand.next() % len(candidates)
787 id = id_setter(-1, "Things")
788 newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
789 world_db["Things"][id] = newT
790 world_db["GOD_MOOD"] += 1 # #
794 """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
796 On success, decrease satiation score by 32.
798 # # 7DRL: Successful heals increment God's mood.
799 if t["T_SATIATION"] > 0 \
800 and t["T_LIFEPOINTS"] < \
801 world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
802 and 0 == (rand.next() % 31) \
803 and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
804 if world_db["ThingActions"][id]["TA_NAME"] ==
806 t["T_LIFEPOINTS"] += 1
807 world_db["GOD_MOOD"] += 1 # #
808 t["T_SATIATION"] -= 32
809 if t == world_db["Things"][0]:
810 strong_write(io_db["file_out"], "LOG You heal.\n")
814 """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
815 if t["T_SATIATION"] > -32768:
816 t["T_SATIATION"] -= 1
817 testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
818 if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
819 raise RuntimeError("A thing that should not hunger is hungering.")
820 stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
821 if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
822 if t == world_db["Things"][0]:
823 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
824 decrement_lifepoints(t)
827 def get_dir_to_target(t, filter):
828 """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
830 The path-wise nearest target is chosen, via the shortest available path.
831 Target must not be t. On succcess, return positive value, else False.
833 "a": Thing in FOV is below a certain distance, animate, but of ThingType
834 that is not t's, and starts out weaker than t is; build path as
835 avoiding things of t's ThingType
836 "f": neighbor cell (not inhabited by any animate Thing) further away from
837 animate Thing not further than x steps away and in FOV and of a
838 ThingType that is not t's, and starts out stronger or as strong as t
839 is currently; or (cornered), if no such flight cell, but Thing of
840 above criteria is too near,1 a cell closer to it, or, if less near,
842 "c": Thing in memorized map is consumable
843 "s": memory map cell with greatest-reachable degree of unexploredness
846 def zero_score_map_where_char_on_memdepthmap(c):
847 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
848 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
849 # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
850 # set_map_score(i, 0)
851 map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
852 if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
853 raise RuntimeError("No score map allocated for "
854 "zero_score_map_where_char_on_memdepthmap().")
856 def set_map_score(pos, score):
857 test = libpr.set_map_score(pos, score)
859 raise RuntimeError("No score map allocated for set_map_score().")
861 def get_map_score(pos):
862 result = libpr.get_map_score(pos)
864 raise RuntimeError("No score map allocated for get_map_score().")
868 if t["fovmap"] and ("a" == filter or "f" == filter):
869 for id in world_db["Things"]:
870 Thing = world_db["Things"][id]
871 if Thing != t and Thing["T_LIFEPOINTS"] and \
872 t["T_TYPE"] != Thing["T_TYPE"] and \
873 'v' == chr(t["fovmap"][(Thing["T_POSY"]
874 * world_db["MAP_LENGTH"])
876 ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
877 if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
879 or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
882 elif t["T_MEMMAP"] and "c" == filter:
883 for mt in t["T_MEMTHING"]:
884 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
886 and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
890 def set_cells_passable_on_memmap_to_65534_on_scoremap():
891 # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
893 # memmap = t["T_MEMMAP"]
894 # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
895 # if ord_dot == memmap[i]]:
896 # set_map_score(i, 65534) # i.e. 65535-1
897 map = c_pointer_to_bytearray(t["T_MEMMAP"])
898 if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
899 raise RuntimeError("No score map allocated for "
900 "set_cells_passable_on_memmap_to_65534_on_scoremap().")
902 def init_score_map():
903 test = libpr.init_score_map()
905 raise RuntimeError("Malloc error in init_score_map().")
908 set_cells_passable_on_memmap_to_65534_on_scoremap()
910 for id in world_db["Things"]:
911 Thing = world_db["Things"][id]
912 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
914 if t != Thing and Thing["T_LIFEPOINTS"] and \
915 t["T_TYPE"] != Thing["T_TYPE"] and \
916 ord_v == t["fovmap"][pos] and \
917 t["T_LIFEPOINTS"] > \
918 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
919 set_map_score(pos, 0)
920 elif t["T_TYPE"] == Thing["T_TYPE"]:
921 set_map_score(pos, 65535)
923 for id in [id for id in world_db["Things"]
924 if world_db["Things"][id]["T_LIFEPOINTS"]]:
925 Thing = world_db["Things"][id]
926 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
928 if t["T_TYPE"] != Thing["T_TYPE"] and \
929 ord_v == t["fovmap"][pos] and \
930 t["T_LIFEPOINTS"] <= \
931 world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
932 set_map_score(pos, 0)
934 for mt in [mt for mt in t["T_MEMTHING"]
935 if ord_blank != t["T_MEMMAP"][mt[1]
936 * world_db["MAP_LENGTH"]
938 if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
939 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
941 zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
943 def rand_target_dir(neighbors, cmp, dirs):
946 for i in range(len(dirs)):
947 if cmp == neighbors[i]:
948 candidates.append(dirs[i])
950 return candidates[rand.next() % n_candidates] if n_candidates else 0
952 def get_neighbor_scores(dirs, eye_pos):
954 if libpr.ready_neighbor_scores(eye_pos):
955 raise RuntimeError("No score map allocated for " +
956 "ready_neighbor_scores.()")
957 for i in range(len(dirs)):
958 scores.append(libpr.get_neighbor_score(i))
961 def get_dir_from_neighbors():
962 dir_to_target = False
964 eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
965 neighbors = get_neighbor_scores(dirs, eye_pos)
967 inhabited = [world_db["Things"][id]["T_POSY"]
968 * world_db["MAP_LENGTH"]
969 + world_db["Things"][id]["T_POSX"]
970 for id in world_db["Things"]
971 if world_db["Things"][id]["T_LIFEPOINTS"]]
972 for i in range(len(dirs)):
973 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
974 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
976 for pos in [pos for pos in inhabited if pos == pos_cmp]:
979 minmax_start = 0 if "f" == filter else 65535 - 1
980 minmax_neighbor = minmax_start
981 for i in range(len(dirs)):
982 if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
983 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
984 or ("f" != filter and minmax_neighbor > neighbors[i]):
985 minmax_neighbor = neighbors[i]
986 if minmax_neighbor != minmax_start:
987 dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
989 if not dir_to_target:
990 if 1 == get_map_score(eye_pos):
991 dir_to_target = rand_target_dir(neighbors, 0, dirs)
992 elif 3 >= get_map_score(eye_pos):
993 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
995 world_db["ThingActions"][id]["TA_NAME"]
998 elif dir_to_target and 3 < get_map_score(eye_pos):
1000 elif "a" == filter and 10 <= get_map_score(eye_pos):
1002 return dir_to_target
1004 dir_to_target = False
1006 run_i = 9 + 1 if "s" == filter else 1
1007 while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1010 mem_depth_c = b'9' if b' ' == mem_depth_c \
1011 else bytes([mem_depth_c[0] - 1])
1012 if libpr.dijkstra_map():
1013 raise RuntimeError("No score map allocated for dijkstra_map().")
1014 dir_to_target = get_dir_from_neighbors()
1015 libpr.free_score_map()
1016 if dir_to_target and str == type(dir_to_target):
1017 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1018 if world_db["ThingActions"][id]["TA_NAME"]
1020 t["T_ARGUMENT"] = ord(dir_to_target)
1021 return dir_to_target
1024 def standing_on_consumable(t):
1025 """Return True/False whether t is standing on a consumable."""
1026 for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1027 if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1028 if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1029 if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1035 def get_inventory_slot_to_consume(t):
1036 """Return slot Id of strongest consumable in t's inventory, else -1."""
1037 cmp_consumability = 0
1040 for id in t["T_CARRIES"]:
1041 type = world_db["Things"][id]["T_TYPE"]
1042 if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > cmp_consumability:
1043 cmp_consumability = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
1050 """Determine next command/argment for actor t via AI algorithms.
1052 AI will look for, and move towards, enemies (animate Things not of their
1053 own ThingType); if they see none, they will consume consumables in their
1054 inventory; if there are none, they will pick up what they stand on if they
1055 stand on consumables; if they stand on none, they will move towards the
1056 next consumable they see or remember on the map; if they see or remember
1057 none, they will explore parts of the map unseen since ever or for at least
1058 one turn; if there is nothing to explore, they will simply wait.
1060 # # 7DRL add: Don't pick up or search things when inventory is full.
1061 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1062 if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1063 if not get_dir_to_target(t, "f"):
1064 sel = get_inventory_slot_to_consume(t)
1066 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1067 if world_db["ThingActions"][id]["TA_NAME"]
1069 t["T_ARGUMENT"] = sel
1070 elif standing_on_consumable(t) \
1071 and (len(t["T_CARRIES"]) < # #
1072 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1073 t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1074 if world_db["ThingActions"][id]["TA_NAME"]
1077 (len(t["T_CARRIES"]) < # #
1078 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1079 and get_dir_to_target(t, "c"))) and \
1080 (not get_dir_to_target(t, "a")):
1081 get_dir_to_target(t, "s")
1085 """Run game world and its inhabitants until new player input expected."""
1087 whilebreaker = False
1088 while world_db["Things"][0]["T_LIFEPOINTS"]:
1089 proliferable_map = world_db["MAP"][:]
1090 for id in [id for id in world_db["Things"]
1091 if not world_db["Things"][id]["carried"]]:
1092 y = world_db["Things"][id]["T_POSY"]
1093 x = world_db["Things"][id]["T_POSX"]
1094 proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
1095 for id in [id for id in world_db["Things"]]: # Only what's from start!
1096 if not id in world_db["Things"] or \
1097 world_db["Things"][id]["carried"]: # May have been consumed or
1098 continue # picked up during turn …
1099 Thing = world_db["Things"][id]
1100 if Thing["T_LIFEPOINTS"]:
1101 if not Thing["T_COMMAND"]:
1102 update_map_memory(Thing)
1108 Thing["T_PROGRESS"] += 1
1109 taid = [a for a in world_db["ThingActions"]
1110 if a == Thing["T_COMMAND"]][0]
1111 ThingAction = world_db["ThingActions"][taid]
1112 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1113 eval("actor_" + ThingAction["TA_NAME"])(Thing)
1114 Thing["T_COMMAND"] = 0
1115 Thing["T_PROGRESS"] = 0
1117 thingproliferation(Thing, proliferable_map)
1120 world_db["TURN"] += 1
1123 def new_Thing(type, pos=(0, 0)):
1124 """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1126 "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1131 "T_PLAYERDROP": 0, # #
1139 "T_MEMDEPTHMAP": False,
1142 if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1143 build_fov_map(thing)
1147 def id_setter(id, category, id_store=False, start_at_1=False):
1148 """Set ID of object of category to manipulate ID unused? Create new one.
1150 The ID is stored as id_store.id (if id_store is set). If the integer of the
1151 input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1152 <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1153 always returned when no new object is created, otherwise the new object's
1156 min = 0 if start_at_1 else -1
1158 id = integer_test(id, min)
1160 if id in world_db[category]:
1165 if (start_at_1 and 0 == id) \
1166 or ((not start_at_1) and (id < 0)):
1167 id = 0 if start_at_1 else -1
1170 if id not in world_db[category]:
1178 """Send PONG line to server output file."""
1179 strong_write(io_db["file_out"], "PONG\n")
1183 """Abort server process."""
1184 if None == opts.replay:
1185 if world_db["WORLD_ACTIVE"]:
1187 atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1188 raise SystemExit("received QUIT command")
1191 def command_thingshere(str_y, str_x):
1192 """Write to out file list of Things known to player at coordinate y, x."""
1193 if world_db["WORLD_ACTIVE"]:
1194 y = integer_test(str_y, 0, 255)
1195 x = integer_test(str_x, 0, 255)
1196 length = world_db["MAP_LENGTH"]
1197 if None != y and None != x and y < length and x < length:
1198 pos = (y * world_db["MAP_LENGTH"]) + x
1199 strong_write(io_db["file_out"], "THINGS_HERE START\n")
1200 if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1201 for id in world_db["Things"]:
1202 if y == world_db["Things"][id]["T_POSY"] \
1203 and x == world_db["Things"][id]["T_POSX"] \
1204 and not world_db["Things"][id]["carried"]:
1205 type = world_db["Things"][id]["T_TYPE"]
1206 name = world_db["ThingTypes"][type]["TT_NAME"]
1207 strong_write(io_db["file_out"], name + "\n")
1209 for mt in world_db["Things"][0]["T_MEMTHING"]:
1210 if y == mt[1] and x == mt[2]:
1211 name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1212 strong_write(io_db["file_out"], name + "\n")
1213 strong_write(io_db["file_out"], "THINGS_HERE END\n")
1215 print("Ignoring: Invalid map coordinates.")
1217 print("Ignoring: Command only works on existing worlds.")
1220 def play_commander(action, args=False):
1221 """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1223 T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1227 id = [x for x in world_db["ThingActions"]
1228 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1229 world_db["Things"][0]["T_COMMAND"] = id
1232 def set_command_and_argument_int(str_arg):
1233 val = integer_test(str_arg, 0, 255)
1235 world_db["Things"][0]["T_ARGUMENT"] = val
1238 def set_command_and_argument_movestring(str_arg):
1239 if str_arg in directions_db:
1240 world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1243 print("Ignoring: Argument must be valid direction string.")
1245 if action == "move":
1246 return set_command_and_argument_movestring
1248 return set_command_and_argument_int
1253 def command_seedrandomness(seed_string):
1254 """Set rand seed to int(seed_string)."""
1255 val = integer_test(seed_string, 0, 4294967295)
1260 def command_makeworld(seed_string):
1261 """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1263 Seed rand with seed. Do more only with a "wait" ThingAction and
1264 world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1265 world_db["Things"] emptied, call make_map() and set
1266 world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1267 according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1268 of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1269 other. Init player's memory map. Write "NEW_WORLD" line to out file.
1275 err = "Space to put thing on too hard to find. Map too small?"
1277 y = rand.next() % world_db["MAP_LENGTH"]
1278 x = rand.next() % world_db["MAP_LENGTH"]
1279 pos = y * world_db["MAP_LENGTH"] + x;
1280 if "." == chr(world_db["MAP"][pos]) \
1281 or ":" == chr(world_db["MAP"][pos]): # #
1285 raise SystemExit(err)
1286 # Replica of C code, wrongly ignores animatedness of new Thing.
1287 pos_clear = (0 == len([id for id in world_db["Things"]
1288 if world_db["Things"][id]["T_LIFEPOINTS"]
1289 if world_db["Things"][id]["T_POSY"] == y
1290 if world_db["Things"][id]["T_POSX"] == x]))
1295 val = integer_test(seed_string, 0, 4294967295)
1299 player_will_be_generated = False
1300 playertype = world_db["PLAYER_TYPE"]
1301 for ThingType in world_db["ThingTypes"]:
1302 if playertype == ThingType:
1303 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1304 player_will_be_generated = True
1306 if not player_will_be_generated:
1307 print("Ignoring: No player type with start number >0 defined.")
1310 for ThingAction in world_db["ThingActions"]:
1311 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1314 print("Ignoring: No thing action with name 'wait' defined.")
1316 world_db["Things"] = {}
1318 world_db["WORLD_ACTIVE"] = 1
1319 world_db["TURN"] = 1
1320 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1321 id = id_setter(-1, "Things")
1322 world_db["Things"][id] = new_Thing(playertype, free_pos())
1323 update_map_memory(world_db["Things"][0])
1324 for type in world_db["ThingTypes"]:
1325 for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1326 if type != playertype:
1327 id = id_setter(-1, "Things")
1328 world_db["Things"][id] = new_Thing(type, free_pos())
1329 strong_write(io_db["file_out"], "NEW_WORLD\n")
1332 def command_maplength(maplength_string):
1333 """Redefine map length. Invalidate map, therefore lose all things on it."""
1334 val = integer_test(maplength_string, 1, 256)
1336 world_db["MAP_LENGTH"] = val
1337 world_db["MAP"] = False
1338 set_world_inactive()
1339 world_db["Things"] = {}
1340 libpr.set_maplength(val)
1343 def command_worldactive(worldactive_string):
1344 """Toggle world_db["WORLD_ACTIVE"] if possible.
1346 An active world can always be set inactive. An inactive world can only be
1347 set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1348 map. On activation, rebuild all Things' FOVs, and the player's map memory.
1350 val = integer_test(worldactive_string, 0, 1)
1352 if 0 != world_db["WORLD_ACTIVE"]:
1354 set_world_inactive()
1356 print("World already active.")
1357 elif 0 == world_db["WORLD_ACTIVE"]:
1359 for ThingAction in world_db["ThingActions"]:
1360 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1363 player_exists = False
1364 for Thing in world_db["Things"]:
1366 player_exists = True
1368 if wait_exists and player_exists and world_db["MAP"]:
1369 for id in world_db["Things"]:
1370 if world_db["Things"][id]["T_LIFEPOINTS"]:
1371 build_fov_map(world_db["Things"][id])
1373 update_map_memory(world_db["Things"][id], False)
1374 world_db["WORLD_ACTIVE"] = 1
1376 print("Ignoring: Not all conditions for world activation met.")
1379 def test_for_id_maker(object, category):
1380 """Return decorator testing for object having "id" attribute."""
1383 if hasattr(object, "id"):
1386 print("Ignoring: No " + category +
1387 " defined to manipulate yet.")
1392 def command_tid(id_string):
1393 """Set ID of Thing to manipulate. ID unused? Create new one.
1395 Default new Thing's type to the first available ThingType, others: zero.
1397 id = id_setter(id_string, "Things", command_tid)
1399 if world_db["ThingTypes"] == {}:
1400 print("Ignoring: No ThingType to settle new Thing in.")
1402 type = list(world_db["ThingTypes"].keys())[0]
1403 world_db["Things"][id] = new_Thing(type)
1406 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1410 def command_tcommand(str_int):
1411 """Set T_COMMAND of selected Thing."""
1412 val = integer_test(str_int, 0)
1414 if 0 == val or val in world_db["ThingActions"]:
1415 world_db["Things"][command_tid.id]["T_COMMAND"] = val
1417 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1421 def command_ttype(str_int):
1422 """Set T_TYPE of selected Thing."""
1423 val = integer_test(str_int, 0)
1425 if val in world_db["ThingTypes"]:
1426 world_db["Things"][command_tid.id]["T_TYPE"] = val
1428 print("Ignoring: ThingType ID belongs to no known ThingType.")
1432 def command_tcarries(str_int):
1433 """Append int(str_int) to T_CARRIES of selected Thing.
1435 The ID int(str_int) must not be of the selected Thing, and must belong to a
1436 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1438 val = integer_test(str_int, 0)
1440 if val == command_tid.id:
1441 print("Ignoring: Thing cannot carry itself.")
1442 elif val in world_db["Things"] \
1443 and not world_db["Things"][val]["carried"]:
1444 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1445 world_db["Things"][val]["carried"] = True
1447 print("Ignoring: Thing not available for carrying.")
1448 # Note that the whole carrying structure is different from the C version:
1449 # Carried-ness is marked by a "carried" flag, not by Things containing
1450 # Things internally.
1454 def command_tmemthing(str_t, str_y, str_x):
1455 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1457 The type must fit to an existing ThingType, and the position into the map.
1459 type = integer_test(str_t, 0)
1460 posy = integer_test(str_y, 0, 255)
1461 posx = integer_test(str_x, 0, 255)
1462 if None != type and None != posy and None != posx:
1463 if type not in world_db["ThingTypes"] \
1464 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1465 print("Ignoring: Illegal value for thing type or position.")
1467 memthing = (type, posy, posx)
1468 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1471 def setter_map(maptype):
1472 """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1474 If no map of maptype exists yet, initialize it with ' ' bytes first.
1477 def valid_map_line(str_int, mapline):
1478 val = integer_test(str_int, 0, 255)
1480 if val >= world_db["MAP_LENGTH"]:
1481 print("Illegal value for map line number.")
1482 elif len(mapline) != world_db["MAP_LENGTH"]:
1483 print("Map line length is unequal map width.")
1488 def nonThingMap_helper(str_int, mapline):
1489 val = valid_map_line(str_int, mapline)
1491 length = world_db["MAP_LENGTH"]
1492 if not world_db["MAP"]:
1493 map = bytearray(b' ' * (length ** 2))
1495 map = world_db["MAP"]
1496 map[val * length:(val * length) + length] = mapline.encode()
1497 if not world_db["MAP"]:
1498 world_db["MAP"] = map
1501 def ThingMap_helper(str_int, mapline):
1502 val = valid_map_line(str_int, mapline)
1504 length = world_db["MAP_LENGTH"]
1505 if not world_db["Things"][command_tid.id][maptype]:
1506 map = bytearray(b' ' * (length ** 2))
1508 map = world_db["Things"][command_tid.id][maptype]
1509 map[val * length:(val * length) + length] = mapline.encode()
1510 if not world_db["Things"][command_tid.id][maptype]:
1511 world_db["Things"][command_tid.id][maptype] = map
1513 return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1516 def setter_tpos(axis):
1517 """Generate setter for T_POSX or T_POSY of selected Thing.
1519 If world is active, rebuilds animate things' fovmap, player's memory map.
1522 def helper(str_int):
1523 val = integer_test(str_int, 0, 255)
1525 if val < world_db["MAP_LENGTH"]:
1526 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1527 if world_db["WORLD_ACTIVE"] \
1528 and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1529 build_fov_map(world_db["Things"][command_tid.id])
1530 if 0 == command_tid.id:
1531 update_map_memory(world_db["Things"][command_tid.id])
1533 print("Ignoring: Position is outside of map.")
1537 def command_ttid(id_string):
1538 """Set ID of ThingType to manipulate. ID unused? Create new one.
1540 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
1542 id = id_setter(id_string, "ThingTypes", command_ttid)
1544 world_db["ThingTypes"][id] = {
1545 "TT_NAME": "(none)",
1548 "TT_PROLIFERATE": 0,
1549 "TT_START_NUMBER": 0,
1550 "TT_STORAGE": 0, # #
1556 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1560 def command_ttname(name):
1561 """Set TT_NAME of selected ThingType."""
1562 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1566 def command_ttsymbol(char):
1567 """Set TT_SYMBOL of selected ThingType. """
1569 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1571 print("Ignoring: Argument must be single character.")
1575 def command_ttcorpseid(str_int):
1576 """Set TT_CORPSE_ID of selected ThingType."""
1577 val = integer_test(str_int, 0)
1579 if val in world_db["ThingTypes"]:
1580 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1582 print("Ignoring: Corpse ID belongs to no known ThignType.")
1585 def command_taid(id_string):
1586 """Set ID of ThingAction to manipulate. ID unused? Create new one.
1588 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1590 id = id_setter(id_string, "ThingActions", command_taid, True)
1592 world_db["ThingActions"][id] = {
1598 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1601 @test_ThingAction_id
1602 def command_taname(name):
1603 """Set TA_NAME of selected ThingAction.
1605 The name must match a valid thing action function. If after the name
1606 setting no ThingAction with name "wait" remains, call set_world_inactive().
1608 if name == "wait" or name == "move" or name == "use" or name == "drop" \
1609 or name == "pick_up":
1610 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1611 if 1 == world_db["WORLD_ACTIVE"]:
1612 wait_defined = False
1613 for id in world_db["ThingActions"]:
1614 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1617 if not wait_defined:
1618 set_world_inactive()
1620 print("Ignoring: Invalid action name.")
1621 # In contrast to the original,naming won't map a function to a ThingAction.
1625 """Call ai() on player Thing, then turn_over()."""
1626 ai(world_db["Things"][0])
1630 """Commands database.
1632 Map command start tokens to ([0]) number of expected command arguments, ([1])
1633 the command's meta-ness (i.e. is it to be written to the record file, is it to
1634 be ignored in replay mode if read from server input file), and ([2]) a function
1638 "QUIT": (0, True, command_quit),
1639 "PING": (0, True, command_ping),
1640 "THINGS_HERE": (2, True, command_thingshere),
1641 "MAKE_WORLD": (1, False, command_makeworld),
1642 "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1643 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1644 "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)), # #
1645 "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)), # #
1646 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1647 "MAP_LENGTH": (1, False, command_maplength),
1648 "WORLD_ACTIVE": (1, False, command_worldactive),
1649 "MAP": (2, False, setter_map("MAP")),
1650 "TA_ID": (1, False, command_taid),
1651 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1652 "TA_NAME": (1, False, command_taname),
1653 "TT_ID": (1, False, command_ttid),
1654 "TT_NAME": (1, False, command_ttname),
1655 "TT_SYMBOL": (1, False, command_ttsymbol),
1656 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1657 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
1659 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1661 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1663 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1664 "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)), # #
1665 "T_ID": (1, False, command_tid),
1666 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1667 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1668 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1669 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1670 "T_COMMAND": (1, False, command_tcommand),
1671 "T_TYPE": (1, False, command_ttype),
1672 "T_CARRIES": (1, False, command_tcarries),
1673 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
1674 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
1675 "T_MEMTHING": (3, False, command_tmemthing),
1676 "T_POSY": (1, False, setter_tpos("Y")),
1677 "T_POSX": (1, False, setter_tpos("X")),
1678 "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)), # #
1679 "wait": (0, False, play_commander("wait")),
1680 "move": (1, False, play_commander("move")),
1681 "pick_up": (0, False, play_commander("pick_up")),
1682 "drop": (1, False, play_commander("drop", True)),
1683 "use": (1, False, play_commander("use", True)),
1684 "ai": (0, False, command_ai)
1688 """World state database. With sane default values. (Randomness is in rand.)"""
1702 """Mapping of direction names to internal direction chars."""
1703 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
1704 "west": "s", "north-west": "w", "north-east": "e"}
1706 """File IO database."""
1708 "path_save": "save",
1709 "path_record": "record_save",
1710 "path_worldconf": "confserver/world",
1711 "path_server": "server/",
1712 "path_in": "server/in",
1713 "path_out": "server/out",
1714 "path_worldstate": "server/worldstate",
1715 "tmp_suffix": "_tmp",
1716 "kicked_by_rival": False,
1717 "worldstate_updateable": False
1722 libpr = prep_library()
1723 rand = RandomnessIO()
1724 opts = parse_command_line_arguments()
1726 io_db["path_save"] = opts.savefile
1727 io_db["path_record"] = "record_" + opts.savefile
1730 io_db["verbose"] = True
1731 if None != opts.replay:
1735 except SystemExit as exit:
1736 print("ABORTING: " + exit.args[0])
1738 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")