home · contact · privacy
9bc55ad815bb6fe788720016b05c1e6c1979ef02
[plomrogue] / roguelike-server
1 #!/usr/bin/python3
2
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.
6
7
8 import argparse
9 import errno
10 import os
11 import shlex
12 import shutil
13 import time
14 import ctypes
15 import math  # #
16
17
18 class RandomnessIO:
19     """"Interface to libplomrogue's pseudo-randomness generator."""
20
21     def set_seed(self, seed):
22         libpr.seed_rrand(1, seed)
23
24     def get_seed(self):
25         return libpr.seed_rrand(0, 0)
26
27     def next(self):
28         return libpr.rrand()
29
30     seed = property(get_seed, set_seed)
31
32
33 def prep_library():
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
40     return libpr
41
42
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)
47
48
49 def strong_write(file, string):
50     """Apply write(string), then flush()."""
51     file.write(string)
52     file.flush()
53
54
55 def setup_server_io():
56     """Fill IO files DB with proper file( path)s. Write process IO test string.
57
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"].
63     """
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):
70             raise SystemExit(msg)
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"])
85
86
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):
90         if file_key in io_db:
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()
100
101
102 def obey(command, prefix, replay=False, do_record=False):
103     """Call function from commands_db mapped to command's first token.
104
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.
115     """
116     server_test()
117     if io_db["verbose"]:
118         print("input " + prefix + ": " + command)
119     try:
120         tokens = shlex.split(command, comments=True)
121     except ValueError as err:
122         print("Can't tokenize command string: " + str(err) + ".")
123         return
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.")
130         elif replay:
131             print("Due to replay mode, reading command as 'go on in record'.")
132             line = io_db["file_record"].readline()
133             if len(line) > 0:
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
137             else:
138                 print("Reached end of record file.")
139         else:
140             commands_db[tokens[0]][2](*tokens[1:])
141             if do_record:
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"],
145                                  do_append=True)
146                     if world_db["WORLD_ACTIVE"]:
147                         save_world()
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.")
153
154
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"]
158     mode = "w"
159     if do_append:
160         mode = "a"
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)
165     file.close()
166     if delete and os.access(path, os.F_OK):
167         os.remove(path)
168     os.rename(path_tmp, path)
169
170
171 def save_world():
172     """Save all commands needed to reconstruct current world state."""
173
174     def quote(string):
175         string = string.replace("\u005C", '\u005C\u005C')
176         return '"' + string.replace('"', '\u005C"') + '"'
177
178     def mapsetter(key):
179         def helper(id=None):
180             string = ""
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) \
188                              + "\n"
189             return string
190         return helper
191
192     def memthing(id):
193         string = ""
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"
197         return string
198
199     def helper(category, id_string, special_keys={}):
200         string = ""
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)
210         return string
211
212     string = ""
213     for key in world_db:
214         if (dict != type(world_db[key])
215             and key != "altar"  # #
216             and key != "MAP" and key != "WORLD_ACTIVE"):
217             string = string + key + " " + str(world_db[key]) + "\n"
218     string = string + mapsetter("MAP")()
219     string = string + helper("ThingActions", "TA_ID")
220     string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
221     for id in world_db["ThingTypes"]:
222         string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
223                  str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
224     string = string + helper("Things", "T_ID",
225                              {"T_CARRIES": False, "carried": False,
226                               "T_MEMMAP": mapsetter("T_MEMMAP"),
227                               "T_MEMTHING": memthing, "fovmap": False,
228                               "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
229     for id in world_db["Things"]:
230         if [] != world_db["Things"][id]["T_CARRIES"]:
231             string = string + "T_ID " + str(id) + "\n"
232             for carried_id in world_db["Things"][id]["T_CARRIES"]:
233                 string = string + "T_CARRIES " + str(carried_id) + "\n"
234     string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
235              "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
236     atomic_write(io_db["path_save"], string)
237
238
239 def obey_lines_in_file(path, name, do_record=False):
240     """Call obey() on each line of path's file, use name in input prefix."""
241     file = open(path, "r")
242     line_n = 1
243     for line in file.readlines():
244         obey(line.rstrip(), name + "file line " + str(line_n),
245              do_record=do_record)
246         line_n = line_n + 1
247     file.close()
248
249
250 def parse_command_line_arguments():
251     """Return settings values read from command line arguments."""
252     parser = argparse.ArgumentParser()
253     parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
254                         action='store')
255     parser.add_argument('-l', nargs="?", const="save", dest='savefile',
256                         action="store")
257     parser.add_argument('-v', dest='verbose', action='store_true')
258     opts, unknown = parser.parse_known_args()
259     return opts
260
261
262 def server_test():
263     """Ensure valid server out file belonging to current process.
264
265     This is done by comparing io_db["teststring"] to what's found at the start
266     of the current file at io_db["path_out"]. On failure, set
267     io_db["kicked_by_rival"] and raise SystemExit.
268     """
269     if not os.access(io_db["path_out"], os.F_OK):
270         raise SystemExit("Server output file has disappeared.")
271     file = open(io_db["path_out"], "r")
272     test = file.readline().rstrip("\n")
273     file.close()
274     if test != io_db["teststring"]:
275         io_db["kicked_by_rival"] = True
276         msg = "Server test string in server output file does not match. This" \
277               " indicates that the current server process has been " \
278               "superseded by another one."
279         raise SystemExit(msg)
280
281
282 def read_command():
283     """Return next newline-delimited command from server in file.
284
285     Keep building return string until a newline is encountered. Pause between
286     unsuccessful reads, and after too much waiting, run server_test().
287     """
288     wait_on_fail = 0.03333
289     max_wait = 5
290     now = time.time()
291     command = ""
292     while True:
293         add = io_db["file_in"].readline()
294         if len(add) > 0:
295             command = command + add
296             if len(command) > 0 and "\n" == command[-1]:
297                 command = command[:-1]
298                 break
299         else:
300             time.sleep(wait_on_fail)
301             if now + max_wait < time.time():
302                 server_test()
303                 now = time.time()
304     return command
305
306
307 def try_worldstate_update():
308     """Write worldstate file if io_db["worldstate_updateable"] is set."""
309     if io_db["worldstate_updateable"]:
310
311         def write_map(string, map):
312             for i in range(length):
313                 line = map[i * length:(i * length) + length].decode()
314                 string = string + line + "\n"
315             return string
316
317         inventory = ""
318         if [] == world_db["Things"][0]["T_CARRIES"]:
319             inventory = "(none)\n"
320         else:
321             for id in world_db["Things"][0]["T_CARRIES"]:
322                 type_id = world_db["Things"][id]["T_TYPE"]
323                 name = world_db["ThingTypes"][type_id]["TT_NAME"]
324                 inventory = inventory + name + "\n"
325         # 7DRL additions:  GOD_MOOD, GOD_FAVOR
326         string = str(world_db["TURN"]) + "\n" + \
327                  str(world_db["GOD_MOOD"]) + "\n" + \
328                  str(world_db["GOD_FAVOR"]) + "\n" + \
329                  str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
330                  str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
331                  inventory + "%\n" + \
332                  str(world_db["Things"][0]["T_POSY"]) + "\n" + \
333                  str(world_db["Things"][0]["T_POSX"]) + "\n" + \
334                  str(world_db["MAP_LENGTH"]) + "\n"
335         length = world_db["MAP_LENGTH"]
336
337         fov = bytearray(b' ' * (length ** 2))
338         ord_v = ord("v")
339         for pos in [pos for pos in range(length ** 2)
340                         if ord_v == world_db["Things"][0]["fovmap"][pos]]:
341             fov[pos] = world_db["MAP"][pos]
342         for id in [id for tid in reversed(sorted(list(world_db["ThingTypes"])))
343                       for id in world_db["Things"]
344                       if not world_db["Things"][id]["carried"]
345                       if world_db["Things"][id]["T_TYPE"] == tid
346                       if world_db["Things"][0]["fovmap"][
347                            world_db["Things"][id]["T_POSY"] * length
348                            + world_db["Things"][id]["T_POSX"]] == ord_v]:
349             type = world_db["Things"][id]["T_TYPE"]
350             c = ord(world_db["ThingTypes"][type]["TT_SYMBOL"])
351             fov[world_db["Things"][id]["T_POSY"] * length
352                 + world_db["Things"][id]["T_POSX"]] = c
353         string = write_map(string, fov)
354
355         mem = world_db["Things"][0]["T_MEMMAP"][:]
356         for mt in [mt for tid in reversed(sorted(list(world_db["ThingTypes"])))
357                       for mt in world_db["Things"][0]["T_MEMTHING"]
358                       if mt[0] == tid]:
359              c = world_db["ThingTypes"][mt[0]]["TT_SYMBOL"]
360              mem[(mt[1] * length) + mt[2]] = ord(c)
361         string = write_map(string, mem)
362
363         stacksmap = bytearray(b'0' * (length ** 2))  # #
364         for id in [id for id in world_db["Things"]  # #
365                       if not world_db["Things"][id]["carried"]  # #
366                       if world_db["Things"][0]["fovmap"][  # #
367                            world_db["Things"][id]["T_POSY"] * length  # #
368                            + world_db["Things"][id]["T_POSX"]] == ord_v]:  # #
369             pos = (world_db["Things"][id]["T_POSY"] * length  # #
370                   + world_db["Things"][id]["T_POSX"])  # #
371             if stacksmap[pos] < ord('2'):  # #
372                 stacksmap[pos] += 1  # #
373         for mt in world_db["Things"][0]["T_MEMTHING"]:  # #
374             pos = mt[1] * length + mt[2]  # #
375             if stacksmap[pos] < ord('2'):  # #
376                 stacksmap[pos] += 1  # #
377         string = write_map(string, stacksmap)  # #
378         
379         atomic_write(io_db["path_worldstate"], string, delete=False)
380         strong_write(io_db["file_out"], "WORLD_UPDATED\n")
381         io_db["worldstate_updateable"] = False
382
383
384 def replay_game():
385     """Replay game from record file.
386
387     Use opts.replay as breakpoint turn to which to replay automatically before
388     switching to manual input by non-meta commands in server input file
389     triggering further reads of record file. Ensure opts.replay is at least 1.
390     Run try_worldstate_update() before each interactive obey()/read_command().
391     """
392     if opts.replay < 1:
393         opts.replay = 1
394     print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
395           " (if so late a turn is to be found).")
396     if not os.access(io_db["path_record"], os.F_OK):
397         raise SystemExit("No record file found to replay.")
398     io_db["file_record"] = open(io_db["path_record"], "r")
399     io_db["file_record"].prefix = "record file line "
400     io_db["file_record"].line_n = 1
401     while world_db["TURN"] < opts.replay:
402         line = io_db["file_record"].readline()
403         if "" == line:
404             break
405         obey(line.rstrip(), io_db["file_record"].prefix
406              + str(io_db["file_record"].line_n))
407         io_db["file_record"].line_n = io_db["file_record"].line_n + 1
408     while True:
409         try_worldstate_update()
410         obey(read_command(), "in file", replay=True)
411
412
413 def play_game():
414     """Play game by server input file commands. Before, load save file found.
415
416     If no save file is found, a new world is generated from the commands in the
417     world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
418     command and all that follow via the server input file. Run
419     try_worldstate_update() before each interactive obey()/read_command().
420     """
421     if os.access(io_db["path_save"], os.F_OK):
422         obey_lines_in_file(io_db["path_save"], "save")
423     else:
424         if not os.access(io_db["path_worldconf"], os.F_OK):
425             msg = "No world config file from which to start a new world."
426             raise SystemExit(msg)
427         obey_lines_in_file(io_db["path_worldconf"], "world config ",
428                            do_record=True)
429         obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
430     while True:
431         try_worldstate_update()
432         obey(read_command(), "in file", do_record=True)
433
434
435 def make_map():
436     """(Re-)make island map.
437
438     Let "~" represent water, "." land, "X" trees: Build island shape randomly,
439     start with one land cell in the middle, then go into cycle of repeatedly
440     selecting a random sea cell and transforming it into land if it is neighbor
441     to land. The cycle ends when a land cell is due to be created at the map's
442     border. Then put some trees on the map (TODO: more precise algorithm desc).
443     """
444     # 7DRL: Also add some ":" cells, and (not surrounded by trees!) "_" altar.
445
446     def is_neighbor(coordinates, type):
447         y = coordinates[0]
448         x = coordinates[1]
449         length = world_db["MAP_LENGTH"]
450         ind = y % 2
451         diag_west = x + (ind > 0)
452         diag_east = x + (ind < (length - 1))
453         pos = (y * length) + x
454         if (y > 0 and diag_east
455             and type == chr(world_db["MAP"][pos - length + ind])) \
456            or (x < (length - 1)
457                and type == chr(world_db["MAP"][pos + 1])) \
458            or (y < (length - 1) and diag_east
459                and type == chr(world_db["MAP"][pos + length + ind])) \
460            or (y > 0 and diag_west
461                and type == chr(world_db["MAP"][pos - length - (not ind)])) \
462            or (x > 0
463                and type == chr(world_db["MAP"][pos - 1])) \
464            or (y < (length - 1) and diag_west
465                and type == chr(world_db["MAP"][pos + length - (not ind)])):
466             return True
467         return False
468
469     world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
470     length = world_db["MAP_LENGTH"]
471     add_half_width = (not (length % 2)) * int(length / 2)
472     world_db["MAP"][int((length ** 2) / 2) + add_half_width] = ord(".")
473     while (1):
474         y = rand.next() % length
475         x = rand.next() % length
476         pos = (y * length) + x
477         if "~" == chr(world_db["MAP"][pos]) and is_neighbor((y, x), "."):
478             if y == 0 or y == (length - 1) or x == 0 or x == (length - 1):
479                 break
480             world_db["MAP"][pos] = ord(".")
481     n_trees = int((length ** 2) / 16)
482     i_trees = 0
483     while (i_trees <= n_trees):
484         single_allowed = rand.next() % 32
485         y = rand.next() % length
486         x = rand.next() % length
487         pos = (y * length) + x
488         if "." == chr(world_db["MAP"][pos]) \
489           and ((not single_allowed) or is_neighbor((y, x), "X")):
490             world_db["MAP"][pos] = ord("X")
491             i_trees += 1
492     # This all-too-precise replica of the original C code misses iter_limit().
493     n_colons = int((length ** 2) / 16)  # #
494     i_colons = 0  # #
495     while (i_colons <= n_colons):  # #
496         single_allowed = rand.next() % 256  # #
497         y = rand.next() % length  # #
498         x = rand.next() % length  # #
499         pos = (y * length) + x  # #
500         if ("." == chr(world_db["MAP"][pos])  # #
501           and ((not single_allowed) or is_neighbor((y, x), ":"))):  # #
502             world_db["MAP"][pos] = ord(":")  # #
503             i_colons += 1  # #
504     altar_placed = False  # #
505     while not altar_placed:  # #
506         y = rand.next() % length  # #
507         x = rand.next() % length  # #
508         pos = (y * length) + x  # #
509         if (("." == chr(world_db["MAP"][pos]  # #
510              or ":" == chr(world_db["MAP"][pos]))
511             and not is_neighbor((y, x), "X"))):  # #
512             world_db["MAP"][pos] = ord("_")  # #
513             world_db["altar"] = (y, x)  # #
514             altar_placed = True  # #
515
516
517 def update_map_memory(t, age_map=True):
518     """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
519
520     def age_some_memdepthmap_on_nonfov_cells():
521         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
522         # ord_v = ord("v")
523         # ord_0 = ord("0")
524         # ord_9 = ord("9")
525         # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
526         #             if not ord_v == t["fovmap"][pos]
527         #             if ord_0 <= t["T_MEMDEPTHMAP"][pos]
528         #             if ord_9 > t["T_MEMDEPTHMAP"][pos]
529         #             if not rand.next() % (2 **
530         #                                   (t["T_MEMDEPTHMAP"][pos] - 48))]:
531         #     t["T_MEMDEPTHMAP"][pos] += 1
532         memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
533         fovmap = c_pointer_to_bytearray(t["fovmap"])
534         libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
535
536     if not t["T_MEMMAP"]:
537         t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
538     if not t["T_MEMDEPTHMAP"]:
539         t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
540     ord_v = ord("v")
541     ord_0 = ord("0")
542     ord_space = ord(" ")
543     for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
544                 if ord_v == t["fovmap"][pos]]:
545         t["T_MEMDEPTHMAP"][pos] = ord_0
546         t["T_MEMMAP"][pos] = world_db["MAP"][pos]
547     if age_map:
548         age_some_memdepthmap_on_nonfov_cells()
549     t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
550                        if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
551                                                + mt[2]]]
552     for id in [id for id in world_db["Things"]
553                if not world_db["Things"][id]["carried"]]:
554         type = world_db["Things"][id]["T_TYPE"]
555         if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
556             y = world_db["Things"][id]["T_POSY"]
557             x = world_db["Things"][id]["T_POSX"]
558             if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
559                 t["T_MEMTHING"].append((type, y, x))
560
561
562 def set_world_inactive():
563     """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
564     server_test()
565     if os.access(io_db["path_worldstate"], os.F_OK):
566         os.remove(io_db["path_worldstate"])
567     world_db["WORLD_ACTIVE"] = 0
568
569
570 def integer_test(val_string, min, max=None):
571     """Return val_string if possible integer >= min and <= max, else None."""
572     try:
573         val = int(val_string)
574         if val < min or (max is not None and val > max):
575             raise ValueError
576         return val
577     except ValueError:
578         msg = "Ignoring: Please use integer >= " + str(min)
579         if max is not None:
580             msg += " and <= " + str(max)
581         msg += "."
582         print(msg)
583         return None
584
585
586 def setter(category, key, min, max=None):
587     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
588     if category is None:
589         def f(val_string):
590             val = integer_test(val_string, min, max)
591             if None != val:
592                 world_db[key] = val
593     else:
594         if category == "Thing":
595             id_store = command_tid
596             decorator = test_Thing_id
597         elif category == "ThingType":
598             id_store = command_ttid
599             decorator = test_ThingType_id
600         elif category == "ThingAction":
601             id_store = command_taid
602             decorator = test_ThingAction_id
603
604         @decorator
605         def f(val_string):
606             val = integer_test(val_string, min, max)
607             if None != val:
608                 world_db[category + "s"][id_store.id][key] = val
609     return f
610
611
612 def build_fov_map(t):
613     """Build Thing's FOV map."""
614     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
615     fovmap = c_pointer_to_bytearray(t["fovmap"])
616     map = c_pointer_to_bytearray(world_db["MAP"])
617     if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
618         raise RuntimeError("Malloc error in build_fov_Map().")
619
620
621 def log_help():
622     """Send quick usage info to log."""
623     strong_write(io_db["file_out"], "LOG "
624                  + "Use 'w'/'e'/'s'/'d'/'x'/'c' to move, and 'w' to wait.\n")
625     strong_write(io_db["file_out"], "LOG "
626                  + "Use 'p' to pick up objects, and 'D' to drop them.\n")
627     strong_write(io_db["file_out"], "LOG "
628                  + "Some objects can be used (such as: eaten) by 'u' if "
629                  + "they are in your inventory. "
630                  + "Use 'Up'/'Down' to navigate the inventory.\n")
631     strong_write(io_db["file_out"], "LOG "
632                  + "Use 'l' to toggle 'look' mode (move an exploration cursor "
633                  + "instead of the player over the map).\n")
634     strong_write(io_db["file_out"], "LOG "
635                  + "Use 'PgUp'/PgDn' to scroll the 'Things here' window.\n")
636     strong_write(io_db["file_out"], "LOG See README file for more details.\n")
637
638
639 def decrement_lifepoints(t):
640     """Decrement t's lifepoints by 1, and if to zero, corpse it.
641
642     If t is the player avatar, only blank its fovmap, so that the client may
643     still display memory data. On non-player things, erase fovmap and memory.
644     Dying actors drop all their things.
645     """
646     # 7DRL: Also decrements God's mood; deaths heavily so.
647     # 7DRL: Return 1 if death, else 0.
648     t["T_LIFEPOINTS"] -= 1
649     world_db["GOD_MOOD"] -= 1  # #
650     if 0 == t["T_LIFEPOINTS"]:
651         sadness = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
652         world_db["GOD_MOOD"] -= sadness  # #        
653         for id in t["T_CARRIES"]:
654             t["T_CARRIES"].remove(id)
655             world_db["Things"][id]["T_POSY"] = t["T_POSY"]
656             world_db["Things"][id]["T_POSX"] = t["T_POSX"]
657             world_db["Things"][id]["carried"] = False
658         t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
659         if world_db["Things"][0] == t:
660             t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
661             strong_write(io_db["file_out"], "LOG You die.\n")
662             strong_write(io_db["file_out"],
663                          "LOG See README on how to start over.\n")
664         else:
665             t["fovmap"] = False
666             t["T_MEMMAP"] = False
667             t["T_MEMDEPTHMAP"] = False
668             t["T_MEMTHING"] = []
669         return sadness  # #
670     return 0  # #
671
672
673 def add_gods_favor(i): # #
674     """"Add to GOD_FAVOR, multiplied with factor growing log. with GOD_MOOD."""
675     def favor_multiplier(i):
676         x = 100
677         threshold = math.e * x
678         mood = world_db["GOD_MOOD"]
679         if i > 0:
680             if mood > threshold:
681                 i = i * math.log(mood / x)
682             elif -mood > threshold:
683                 i = i / math.log(-mood / x)
684         elif i < 0:
685             if -mood > threshold:
686                 i = i * math.log(-mood / x)
687             if mood > threshold:
688                 i = i / math.log(mood / x)
689         return int(i)
690     world_db["GOD_FAVOR"] += favor_multiplier(i)
691
692
693 def mv_yx_in_dir_legal(dir, y, x):
694     """Wrapper around libpr.mv_yx_in_dir_legal to simplify its use."""
695     dir_c = dir.encode("ascii")[0]
696     test = libpr.mv_yx_in_dir_legal_wrap(dir_c, y, x)
697     if -1 == test:
698         raise RuntimeError("Too much wrapping in mv_yx_in_dir_legal_wrap()!")
699     return (test, libpr.result_y(), libpr.result_x())
700
701
702 def enter_altar():  # #
703      """What happens when the player enters the altar."""
704      if world_db["FAVOR_STAGE"] > 9000:
705         strong_write(io_db["file_out"],
706                      "LOG You step on a soul-less slab of stone.\n")
707         return
708      strong_write(io_db["file_out"], "LOG YOU ENTER SACRED GROUND.\n")
709      if world_db["FAVOR_STAGE"] == 0:
710          world_db["FAVOR_STAGE"] = 1
711          strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
712                       + "\"I don't trust you. You intrude on the island's "
713                       + "affairs. I think you're a nuisance at best, and a "
714                       + "danger to my children at worst. I will give you a "
715                       + "chance to lighten my mood, however: For a while now, "
716                       + "I've been trying to spread the plant "
717                       + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
718                       + " (\""
719                       + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_SYMBOL"]
720                       + "\"). I have not been very successful so far. Maybe "
721                       + "you can make yourself useful there. I will count "
722                       + "each further "
723                       + world_db["ThingTypes"][world_db["PLANT_0"]]["TT_NAME"]
724                       + " that grows to your favor.\n")
725      elif world_db["FAVOR_STAGE"] == 1 and world_db["GOD_FAVOR"] >= 100:
726          world_db["FAVOR_STAGE"] = 2
727          strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
728                       + "\"You could have done worse so far. Maybe you are not "
729                       + "the worst to happen to this island since the metal "
730                       + "birds threw the great lightning ball. Maybe you can "
731                       + "help me spread another plant. It multiplies faster, "
732                       + "and it is highly nutritious: "
733                       + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
734                       + " (\""
735                       + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_SYMBOL"]
736                       + "\"). It is new. I give you the only example. Be very "
737                       + "careful with it! I also give you another tool that "
738                       + "might be helpful.\n")
739          id = id_setter(-1, "Things")
740          world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
741                                             world_db["altar"])
742          id = id_setter(-1, "Things")
743          world_db["Things"][id] = new_Thing(world_db["TOOL_0"],
744                                             world_db["altar"])
745      elif world_db["FAVOR_STAGE"] == 2 and \
746           0 == len([id for id in world_db["Things"]
747                    if world_db["Things"][id]["T_TYPE"]
748                       == world_db["PLANT_1"]]):
749          strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
750                       + "\"I am greatly disappointed that you lost all "
751                       + world_db["ThingTypes"][world_db["PLANT_1"]]["TT_NAME"]
752                       + " this island had. Here is another one. It cost me "
753                       + " great work. Be more careful this time.\n")
754          id = id_setter(-1, "Things")
755          world_db["Things"][id] = new_Thing(world_db["PLANT_1"],
756                                             world_db["altar"])
757          add_gods_favor(-250)
758      elif world_db["GOD_FAVOR"] > 9000:
759          world_db["FAVOR_STAGE"] = 9001
760          strong_write(io_db["file_out"], "LOG The Island God speaks to you: "
761                       + "\"You have proven yourself worthy of my respect. "
762                       + "You were a good citizen to the island, and sometimes "
763                       + "a better steward to its inhabitants than me. The "
764                       + "island shall miss you when you leave. But you have "
765                       + "earned the right to do so. Take this "
766                       + world_db["ThingTypes"][world_db["SLIPPERS"]]["TT_NAME"]
767                       + " and USE it when you please. It will take you to "
768                       + "where you came from. (But do feel free to stay here "
769                       + "as long as you like.)\"\n")
770          id = id_setter(-1, "Things")
771          world_db["Things"][id] = new_Thing(world_db["SLIPPERS"],
772                                             world_db["altar"])
773
774
775 def actor_wait(t):
776     """Make t do nothing (but loudly, if player avatar)."""
777     if t == world_db["Things"][0]:
778         strong_write(io_db["file_out"], "LOG You wait.\n")
779
780
781 def actor_move(t):
782     """If passable, move/collide(=attack) thing into T_ARGUMENT's direction."""
783     # 7DRL: Player wounding (worse: killing) others will lower God's favor.
784     # 7DRL: Player entering the altar triggers enter_altar().
785     # 7DRL: Player with axe chops down trees.
786     passable = False
787     move_result = mv_yx_in_dir_legal(chr(t["T_ARGUMENT"]),
788                                      t["T_POSY"], t["T_POSX"])
789     if 1 == move_result[0]:
790         pos = (move_result[1] * world_db["MAP_LENGTH"]) + move_result[2]
791         hitted = [id for id in world_db["Things"]
792                   if world_db["Things"][id] != t
793                   if world_db["Things"][id]["T_LIFEPOINTS"]
794                   if world_db["Things"][id]["T_POSY"] == move_result[1]
795                   if world_db["Things"][id]["T_POSX"] == move_result[2]]
796         if len(hitted):
797             hit_id = hitted[0]
798             if t == world_db["Things"][0]:
799                 hitted_type = world_db["Things"][hit_id]["T_TYPE"]
800                 hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
801                 strong_write(io_db["file_out"], "LOG You wound " + hitted_name
802                                                 + ".\n")
803                 add_gods_favor(-1)  # #
804             elif 0 == hit_id:
805                 hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
806                 strong_write(io_db["file_out"], "LOG " + hitter_name +
807                                                 " wounds you.\n")
808             test = decrement_lifepoints(world_db["Things"][hit_id])  # #(test=)
809             if test and t == world_db["Things"][0]:  # #
810                 add_gods_favor(-test)  # #
811             return
812         if (ord("X") == world_db["MAP"][pos]  # #
813             or ord("|") == world_db["MAP"][pos]):  # #
814             carries_axe = False  # #
815             for id in t["T_CARRIES"]:  # # 
816                 type = world_db["Things"][id]["T_TYPE"]  # #
817                 if world_db["ThingTypes"][type]["TT_TOOL"] == "axe":  # #
818                     carries_axe = True  # #
819                     break  # #
820             if carries_axe:  # #
821                 axe_name = world_db["ThingTypes"][type]["TT_NAME"]  # #
822                 if t == world_db["Things"][0]:  # #
823                     strong_write(io_db["file_out"], "LOG With your "  # #
824                                                     + axe_name  # #
825                                                     + ", you chop!\n")  # #
826                     if ord("X") == world_db["MAP"][pos]:  # #
827                         add_gods_favor(-1)  # #
828                 chop_power = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
829                 case_X = world_db["MAP"][pos] == ord("X")  # #
830                 if (chop_power > 0  # #
831                     and ((case_X and  # #
832                           0 == int(rand.next() / chop_power))  # #
833                     or (not case_X and  # #
834                              0 == int(rand.next() / (3 * chop_power))))):  # #
835                     if t == world_db["Things"][0]:  # #
836                         strong_write(io_db["file_out"],  # #
837                                      "LOG You chop it down.\n")  # #
838                     if world_db["MAP"][pos] == ord("X"):  # #
839                         add_gods_favor(-10)  # #
840                     world_db["MAP"][pos] = ord(".")   # #
841                     i = 3 if case_X else 1  # #
842                     for i in range(i):  # #
843                         id = id_setter(-1, "Things")  # #
844                         world_db["Things"][id] = \
845                           new_Thing(world_db["LUMBER"],  # #
846                                     (move_result[1], move_result[2]))  # # 
847                     build_fov_map(t)  # #
848                 return   # #
849         passable = ("." == chr(world_db["MAP"][pos]) or
850                     ":" == chr(world_db["MAP"][pos]) or # #
851                     "_" == chr(world_db["MAP"][pos])) # #
852     dir = [dir for dir in directions_db
853            if directions_db[dir] == chr(t["T_ARGUMENT"])][0]
854     if passable:
855         t["T_POSY"] = move_result[1]
856         t["T_POSX"] = move_result[2]
857         for id in t["T_CARRIES"]:
858             world_db["Things"][id]["T_POSY"] = move_result[1]
859             world_db["Things"][id]["T_POSX"] = move_result[2]
860         build_fov_map(t)
861         if t == world_db["Things"][0]:
862             strong_write(io_db["file_out"], "LOG You move " + dir + ".\n")
863             if (move_result[1] == world_db["altar"][0] and  # #
864                 move_result[2] == world_db["altar"][1]):  # #
865                 enter_altar()  # #
866     elif t == world_db["Things"][0]:
867         strong_write(io_db["file_out"], "LOG You fail to move " + dir + ".\n")
868
869
870 def actor_pick_up(t):
871     """Make t pick up (topmost?) Thing from ground into inventory.
872
873     Define topmostness by how low the thing's type ID is.
874     """
875     # 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
876     used_slots = len(t["T_CARRIES"]) # #
877     if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
878         ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
879                if not world_db["Things"][id]["carried"]
880                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
881                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
882         if len(ids):
883             lowest_tid = -1
884             for iid in ids:
885                 tid = world_db["Things"][iid]["T_TYPE"] 
886                 if lowest_tid == -1 or tid < lowest_tid:
887                     id = iid
888                     lowest_tid = tid
889             world_db["Things"][id]["carried"] = True
890             type = world_db["Things"][id]["T_TYPE"]  # #
891             if (t != world_db["Things"][0] # #
892                 and world_db["Things"][id]["T_PLAYERDROP"]  # #
893                 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"):  # #
894                 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32  # #
895                 add_gods_favor(score)  # #
896                 world_db["Things"][id]["T_PLAYERDROP"] = 0  # #
897             t["T_CARRIES"].append(id)
898             if t == world_db["Things"][0]:
899                 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
900         elif t == world_db["Things"][0]:
901             err = "You try to pick up an object, but there is none."
902             strong_write(io_db["file_out"], "LOG " + err + "\n")
903     elif t == world_db["Things"][0]: # #
904         strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
905                                         "No storage room to carry more.\n") # #
906
907
908 def actor_drop(t):
909     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
910     # TODO: Handle case where T_ARGUMENT matches nothing.
911     if len(t["T_CARRIES"]):
912         id = t["T_CARRIES"][t["T_ARGUMENT"]]
913         t["T_CARRIES"].remove(id)
914         world_db["Things"][id]["carried"] = False
915         if t == world_db["Things"][0]:
916             strong_write(io_db["file_out"], "LOG You drop an object.\n")
917             world_db["Things"][id]["T_PLAYERDROP"] = 1  # #
918     elif t == world_db["Things"][0]:
919         err = "You try to drop an object, but you own none."
920         strong_write(io_db["file_out"], "LOG " + err + "\n")
921
922
923 def actor_use(t):
924     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
925     # TODO: Handle case where T_ARGUMENT matches nothing.
926     # 7DLR: Handle SLIPPERS-type Thing use.
927     if len(t["T_CARRIES"]):
928         id = t["T_CARRIES"][t["T_ARGUMENT"]]
929         type = world_db["Things"][id]["T_TYPE"]
930         if type == world_db["SLIPPERS"]:  # #
931             if t == world_db["Things"][0]:  # #
932                 strong_write(io_db["file_out"], "LOG You use the "  # #
933                              + world_db["ThingTypes"][type]["TT_NAME"]  # #
934                              + ". It glows in wondrous colors, and emits "  # #
935                              + "a sound as if from a dying cat. The "  # #
936                              + "Island God laughs.\n")  # #
937             t["T_LIFEPOINTS"] = 1  # #
938             decrement_lifepoints(t)  # #
939         elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe"  # #
940               and t == world_db["Things"][0]):  # #
941                 strong_write(io_db["file_out"],  # #
942                              "LOG To use this item for chopping, move "  # #
943                              "towards a tree while carrying it in "  # #
944                              "your inventory.\n")  # #
945         elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"):  # #
946             pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
947             if (world_db["MAP"][pos] == ord("X")  # #
948                 or world_db["MAP"][pos] == ord("|")):  # #
949                 strong_write(io_db["file_out"],  # #
950                              "LOG Can't build when standing on barrier.\n")  # #
951                 return
952             for id in [id for id in world_db["Things"]
953                        if not world_db["Things"][id] == t
954                        if not world_db["Things"][id]["carried"]
955                        if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
956                        if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
957                  strong_write(io_db["file_out"],
958                               "LOG Can't build when standing objects.\n")  # #
959                  return
960             for id in t["T_CARRIES"]:  # #
961                 type_tool = world_db["Things"][id]["T_TYPE"]  # #
962                 if (world_db["ThingTypes"][type_tool]["TT_TOOL"]  # #
963                     == "carpentry"):  # #
964                     break  # #
965             wood_id = None  # #
966             for id in t["T_CARRIES"]:  # #
967                 type_material = world_db["Things"][id]["T_TYPE"]  # #
968                 if (world_db["ThingTypes"][type_material]["TT_TOOL"]  # #
969                     == "wood"):  # #
970                     wood_id = id  # #
971                     break  # #
972             if wood_id != None:  # #
973                 t["T_CARRIES"].remove(wood_id)  # #
974                 del world_db["Things"][wood_id]  # #
975                 world_db["MAP"][pos] = ord("|")  # #
976                 strong_write(io_db["file_out"], "LOG With your "  # #
977                              + world_db["ThingTypes"][type_tool]["TT_NAME"]  # #
978                              + " you build a wooden barrier from your "  # #
979                              + world_db["ThingTypes"][type_material]  # #
980                                ["TT_NAME"]  # #
981                              + ".\n")  # #
982             else:  # #
983                 strong_write(io_db["file_out"], "LOG You can't use a "  # #
984                              + world_db["ThingTypes"][type_tool]["TT_NAME"]  # #
985                              + " without some wood in your inventory.\n")  # #
986         elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
987             t["T_CARRIES"].remove(id)
988             del world_db["Things"][id]
989             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
990             if t == world_db["Things"][0]:
991                 strong_write(io_db["file_out"],
992                              "LOG You consume this object.\n")
993         elif t == world_db["Things"][0]:
994             strong_write(io_db["file_out"],
995                          "LOG You try to use this object, but fail.\n")
996     elif t == world_db["Things"][0]:
997         strong_write(io_db["file_out"],
998                      "LOG You try to use an object, but you own none.\n")
999
1000
1001 def thingproliferation(t, prol_map):
1002     """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1003
1004     Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1005     marked "." in prol_map. If there are several map cell candidates, one is
1006     selected randomly.
1007     """
1008     # 7DRL: success increments God's mood
1009     # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1010     prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1011     if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1012         candidates = []
1013         for dir in [directions_db[key] for key in directions_db]:
1014             mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1015             pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1016             if mv_result[0] and \
1017                (ord(":") == prol_map[pos]  # #
1018                 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
1019                     and ord(".") == prol_map[pos])):
1020             # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1021             #                                          * world_db["MAP_LENGTH"]
1022             #                                          + mv_result[2]]:
1023                 candidates.append((mv_result[1], mv_result[2]))
1024         if len(candidates):
1025             i = rand.next() % len(candidates)
1026             id = id_setter(-1, "Things")
1027             newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1028             world_db["Things"][id] = newT
1029             animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
1030             if animacy:  # #
1031                 world_db["GOD_MOOD"] += animacy  # #
1032             else:  # #
1033                 world_db["GOD_MOOD"] += 1  # #
1034             if (world_db["FAVOR_STAGE"] > 0  # #
1035                 and t["T_TYPE"] == world_db["PLANT_0"]):  # #
1036                 world_db["GOD_FAVOR"] += 5  # #
1037             elif t["T_TYPE"] == world_db["PLANT_1"]:  # #
1038                 world_db["GOD_FAVOR"] += 25  # #
1039
1040
1041 def try_healing(t):
1042     """Grow t's HP to a 1/32 chance if < HP max, satiation > 0, and waiting.
1043
1044     On success, decrease satiation score by 32.
1045     """
1046     # 7DRL: Successful heals increment God's mood.
1047     if t["T_SATIATION"] > 0 \
1048        and t["T_LIFEPOINTS"] < \
1049            world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
1050        and 0 == (rand.next() % 31) \
1051        and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
1052                               if world_db["ThingActions"][id]["TA_NAME"] ==
1053                                  "wait"][0]:
1054         t["T_LIFEPOINTS"] += 1
1055         world_db["GOD_MOOD"] += 1  # #
1056         t["T_SATIATION"] -= 32
1057         if t == world_db["Things"][0]:
1058             strong_write(io_db["file_out"], "LOG You heal.\n")
1059
1060
1061 def hunger(t):
1062     """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1063     if t["T_SATIATION"] > -32768:
1064         t["T_SATIATION"] -= 1
1065     testbase = t["T_SATIATION"] if t["T_SATIATION"] >= 0 else -t["T_SATIATION"]
1066     if not world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1067         raise RuntimeError("A thing that should not hunger is hungering.")
1068     stomach = int(32767 / world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"])
1069     if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
1070         if t == world_db["Things"][0]:
1071             strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
1072         decrement_lifepoints(t)
1073
1074
1075 def get_dir_to_target(t, filter):
1076     """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1077
1078     The path-wise nearest target is chosen, via the shortest available path.
1079     Target must not be t. On succcess, return positive value, else False.
1080     Filters:
1081     "a": Thing in FOV is below a certain distance, animate, but of ThingType
1082          that is not t's, and starts out weaker than t is; build path as
1083          avoiding things of t's ThingType
1084     "f": neighbor cell (not inhabited by any animate Thing) further away from
1085          animate Thing not further than x steps away and in FOV and of a
1086          ThingType that is not t's, and starts out stronger or as strong as t
1087          is currently; or (cornered), if no such flight cell, but Thing of
1088          above criteria is too near,1 a cell closer to it, or, if less near,
1089          just wait
1090     "c": Thing in memorized map is consumable
1091     "s": memory map cell with greatest-reachable degree of unexploredness
1092     """
1093
1094     def zero_score_map_where_char_on_memdepthmap(c):
1095         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1096         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1097         #           if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1098         #     set_map_score(i, 0)
1099         map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1100         if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1101             raise RuntimeError("No score map allocated for "
1102                                "zero_score_map_where_char_on_memdepthmap().")
1103
1104     def set_map_score(pos, score):
1105         test = libpr.set_map_score(pos, score)
1106         if test:
1107             raise RuntimeError("No score map allocated for set_map_score().")
1108
1109     def get_map_score(pos):
1110         result = libpr.get_map_score(pos)
1111         if result < 0:
1112             raise RuntimeError("No score map allocated for get_map_score().")
1113         return result
1114
1115     def seeing_thing():
1116         if t["fovmap"] and ("a" == filter or "f" == filter):
1117             for id in world_db["Things"]:
1118                 Thing = world_db["Things"][id]
1119                 if Thing != t and Thing["T_LIFEPOINTS"] and \
1120                    t["T_TYPE"] != Thing["T_TYPE"] and \
1121                    'v' == chr(t["fovmap"][(Thing["T_POSY"]
1122                                           * world_db["MAP_LENGTH"])
1123                                           + Thing["T_POSX"]]):
1124                     ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1125                     if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1126                                           t["T_LIFEPOINTS"]) \
1127                        or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1128                                              t["T_LIFEPOINTS"]):
1129                         return True
1130         elif t["T_MEMMAP"] and "c" == filter:
1131             for mt in t["T_MEMTHING"]:
1132                 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1133                                          + mt[2]]) \
1134                    and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1135                     return True
1136         return False
1137
1138     def set_cells_passable_on_memmap_to_65534_on_scoremap():
1139         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1140         # ord_dot = ord(".")
1141         # memmap = t["T_MEMMAP"]
1142         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1143         #            if ord_dot == memmap[i]]:
1144         #     set_map_score(i, 65534) # i.e. 65535-1
1145         map = c_pointer_to_bytearray(t["T_MEMMAP"])
1146         if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1147             raise RuntimeError("No score map allocated for "
1148                         "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1149
1150     def init_score_map():
1151         test = libpr.init_score_map()
1152         if test:
1153             raise RuntimeError("Malloc error in init_score_map().")
1154         ord_v = ord("v")
1155         ord_blank = ord(" ")
1156         set_cells_passable_on_memmap_to_65534_on_scoremap()
1157         if "a" == filter:
1158             for id in world_db["Things"]:
1159                 Thing = world_db["Things"][id]
1160                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1161                       + Thing["T_POSX"]
1162                 if t != Thing and Thing["T_LIFEPOINTS"] and \
1163                    t["T_TYPE"] != Thing["T_TYPE"] and \
1164                    ord_v == t["fovmap"][pos] and \
1165                    t["T_LIFEPOINTS"] > \
1166                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1167                     set_map_score(pos, 0)
1168                 elif t["T_TYPE"] == Thing["T_TYPE"]:
1169                     set_map_score(pos, 65535)
1170         elif "f" == filter:
1171             for id in [id for id in world_db["Things"]
1172                        if world_db["Things"][id]["T_LIFEPOINTS"]]:
1173                 Thing = world_db["Things"][id]
1174                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1175                       + Thing["T_POSX"]
1176                 if t["T_TYPE"] != Thing["T_TYPE"] and \
1177                    ord_v == t["fovmap"][pos] and \
1178                    t["T_LIFEPOINTS"] <= \
1179                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1180                     set_map_score(pos, 0)
1181         elif "c" == filter:
1182             for mt in [mt for mt in t["T_MEMTHING"]
1183                        if ord_blank != t["T_MEMMAP"][mt[1]
1184                                                     * world_db["MAP_LENGTH"]
1185                                                     + mt[2]]
1186                        if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1187                 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1188         elif "s" == filter:
1189             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1190
1191     def rand_target_dir(neighbors, cmp, dirs):
1192         candidates = []
1193         n_candidates = 0
1194         for i in range(len(dirs)):
1195             if cmp == neighbors[i]:
1196                 candidates.append(dirs[i])
1197                 n_candidates += 1
1198         return candidates[rand.next() % n_candidates] if n_candidates else 0
1199
1200     def get_neighbor_scores(dirs, eye_pos):
1201         scores = []
1202         if libpr.ready_neighbor_scores(eye_pos):
1203             raise RuntimeError("No score map allocated for " +
1204                                "ready_neighbor_scores.()")
1205         for i in range(len(dirs)):
1206             scores.append(libpr.get_neighbor_score(i))
1207         return scores
1208
1209     def get_dir_from_neighbors():
1210         dir_to_target = False
1211         dirs = "edcxsw"
1212         eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1213         neighbors = get_neighbor_scores(dirs, eye_pos)
1214         if "f" == filter:
1215             inhabited = [world_db["Things"][id]["T_POSY"]
1216                          * world_db["MAP_LENGTH"]
1217                          + world_db["Things"][id]["T_POSX"]
1218                          for id in world_db["Things"]
1219                          if world_db["Things"][id]["T_LIFEPOINTS"]]
1220             for i in range(len(dirs)):
1221                 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1222                 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1223                           + libpr.result_x()
1224                 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1225                     neighbors[i] = 65535
1226                     break
1227         minmax_start = 0 if "f" == filter else 65535 - 1
1228         minmax_neighbor = minmax_start
1229         for i in range(len(dirs)):
1230             if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1231                 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1232                or ("f" != filter and minmax_neighbor > neighbors[i]):
1233                 minmax_neighbor = neighbors[i]
1234         if minmax_neighbor != minmax_start:
1235             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1236         if "f" == filter:
1237             if not dir_to_target:
1238                 if 1 == get_map_score(eye_pos):
1239                     dir_to_target = rand_target_dir(neighbors, 0, dirs)
1240                 elif 3 >= get_map_score(eye_pos):
1241                     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1242                                       if
1243                                       world_db["ThingActions"][id]["TA_NAME"]
1244                                          == "wait"][0]
1245                     return 1
1246             elif dir_to_target and 3 < get_map_score(eye_pos):
1247                 dir_to_target = 0
1248         elif "a" == filter and 10 <= get_map_score(eye_pos):
1249             dir_to_target = 0
1250         return dir_to_target
1251
1252     dir_to_target = False
1253     mem_depth_c = b' '
1254     run_i = 9 + 1 if "s" == filter else 1
1255     while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1256         run_i -= 1
1257         init_score_map()
1258         mem_depth_c = b'9' if b' ' == mem_depth_c \
1259                            else bytes([mem_depth_c[0] - 1])
1260         if libpr.dijkstra_map():
1261             raise RuntimeError("No score map allocated for dijkstra_map().")
1262         dir_to_target = get_dir_from_neighbors()
1263         libpr.free_score_map()
1264         if dir_to_target and str == type(dir_to_target):
1265             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1266                               if world_db["ThingActions"][id]["TA_NAME"]
1267                                  == "move"][0]
1268             t["T_ARGUMENT"] = ord(dir_to_target)
1269     return dir_to_target
1270
1271
1272 def standing_on_food(t):
1273     """Return True/False whether t is standing on a consumable."""
1274     for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1275                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1276                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1277                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1278                   ["TT_TOOL"] == "food"]:
1279         return True
1280     return False
1281
1282
1283 def get_inventory_slot_to_consume(t):
1284     """Return slot Id of strongest consumable in t's inventory, else -1."""
1285     cmp_food = 0
1286     selection = -1
1287     i = 0
1288     for id in t["T_CARRIES"]:
1289         type = world_db["Things"][id]["T_TYPE"]
1290         if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1291            and world_db["ThingTypes"][type]["TT_TOOLPOWER"] > cmp_food:
1292             cmp_food = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1293             selection = i
1294         i += 1
1295     return selection
1296
1297
1298 def ai(t):
1299     """Determine next command/argment for actor t via AI algorithms.
1300
1301     AI will look for, and move towards, enemies (animate Things not of their
1302     own ThingType); if they see none, they will consume consumables in their
1303     inventory; if there are none, they will pick up what they stand on if they
1304     stand on consumables; if they stand on none, they will move towards the
1305     next consumable they see or remember on the map; if they see or remember
1306     none, they will explore parts of the map unseen since ever or for at least
1307     one turn; if there is nothing to explore, they will simply wait.
1308     """
1309     # 7DRL add: Don't pick up or search things when inventory is full.
1310     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1311                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1312     if not get_dir_to_target(t, "f"):
1313         sel = get_inventory_slot_to_consume(t)
1314         if -1 != sel:
1315             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1316                               if world_db["ThingActions"][id]["TA_NAME"]
1317                                  == "use"][0]
1318             t["T_ARGUMENT"] = sel
1319         elif standing_on_food(t) \
1320              and (len(t["T_CARRIES"]) < # #
1321                  world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1322             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1323                               if world_db["ThingActions"][id]["TA_NAME"]
1324                                  == "pick_up"][0]
1325         elif (not
1326               (len(t["T_CARRIES"]) < # #
1327                 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1328                and get_dir_to_target(t, "c"))) and \
1329              (not get_dir_to_target(t, "a")):
1330             get_dir_to_target(t, "s")
1331
1332
1333 def turn_over():
1334     """Run game world and its inhabitants until new player input expected."""
1335     id = 0
1336     whilebreaker = False
1337     while world_db["Things"][0]["T_LIFEPOINTS"]:
1338         proliferable_map = world_db["MAP"][:]
1339         for id in [id for id in world_db["Things"]
1340                    if not world_db["Things"][id]["carried"]]:
1341             y = world_db["Things"][id]["T_POSY"]
1342             x = world_db["Things"][id]["T_POSX"]
1343             proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1344         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1345             if not id in world_db["Things"] or \
1346                world_db["Things"][id]["carried"]:   # May have been consumed or
1347                 continue                            # picked up during turn …
1348             Thing = world_db["Things"][id]
1349             if Thing["T_LIFEPOINTS"]:
1350                 if not Thing["T_COMMAND"]:
1351                     update_map_memory(Thing)
1352                     if 0 == id:
1353                         whilebreaker = True
1354                         break
1355                     ai(Thing)
1356                 try_healing(Thing)
1357                 hunger(Thing)
1358                 if Thing["T_LIFEPOINTS"]:
1359                     Thing["T_PROGRESS"] += 1
1360                     taid = [a for a in world_db["ThingActions"]
1361                               if a == Thing["T_COMMAND"]][0]
1362                     ThingAction = world_db["ThingActions"][taid]
1363                     if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1364                         eval("actor_" + ThingAction["TA_NAME"])(Thing)
1365                         Thing["T_COMMAND"] = 0
1366                         Thing["T_PROGRESS"] = 0
1367             thingproliferation(Thing, proliferable_map)
1368         if whilebreaker:
1369             break
1370         world_db["TURN"] += 1
1371
1372
1373 def new_Thing(type, pos=(0, 0)):
1374     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1375     thing = {
1376         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1377         "T_ARGUMENT": 0,
1378         "T_PROGRESS": 0,
1379         "T_SATIATION": 0,
1380         "T_COMMAND": 0,
1381         "T_PLAYERDROP": 0,  # #
1382         "T_TYPE": type,
1383         "T_POSY": pos[0],
1384         "T_POSX": pos[1],
1385         "T_CARRIES": [],
1386         "carried": False,
1387         "T_MEMTHING": [],
1388         "T_MEMMAP": False,
1389         "T_MEMDEPTHMAP": False,
1390         "fovmap": False
1391     }
1392     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1393         build_fov_map(thing)
1394     return thing
1395
1396
1397 def id_setter(id, category, id_store=False, start_at_1=False):
1398     """Set ID of object of category to manipulate ID unused? Create new one.
1399
1400     The ID is stored as id_store.id (if id_store is set). If the integer of the
1401     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1402     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1403     always returned when no new object is created, otherwise the new object's
1404     ID.
1405     """
1406     min = 0 if start_at_1 else -1
1407     if str == type(id):
1408         id = integer_test(id, min)
1409     if None != id:
1410         if id in world_db[category]:
1411             if id_store:
1412                 id_store.id = id
1413             return None
1414         else:
1415             if (start_at_1 and 0 == id) \
1416                or ((not start_at_1) and (id < 0)):
1417                 id = 0 if start_at_1 else -1
1418                 while 1:
1419                     id = id + 1
1420                     if id not in world_db[category]:
1421                         break
1422             if id_store:
1423                 id_store.id = id
1424     return id
1425
1426
1427 def command_ping():
1428     """Send PONG line to server output file."""
1429     strong_write(io_db["file_out"], "PONG\n")
1430
1431
1432 def command_quit():
1433     """Abort server process."""
1434     if None == opts.replay:
1435         if world_db["WORLD_ACTIVE"]:
1436             save_world()
1437         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1438     raise SystemExit("received QUIT command")
1439
1440
1441 def command_thingshere(str_y, str_x):
1442     """Write to out file list of Things known to player at coordinate y, x."""
1443     # 7DRL: terrain, too
1444     if world_db["WORLD_ACTIVE"]:
1445         y = integer_test(str_y, 0, 255)
1446         x = integer_test(str_x, 0, 255)
1447         length = world_db["MAP_LENGTH"]
1448         if None != y and None != x and y < length and x < length:
1449             pos = (y * world_db["MAP_LENGTH"]) + x
1450             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1451             pos = y * world_db["MAP_LENGTH"] + x;  # #
1452             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1453                 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1454                               for id in world_db["Things"]
1455                               if not world_db["Things"][id]["carried"]
1456                               if world_db["Things"][id]["T_TYPE"] == tid
1457                               if y == world_db["Things"][id]["T_POSY"]
1458                               if x == world_db["Things"][id]["T_POSX"]]:
1459                     type = world_db["Things"][id]["T_TYPE"]
1460                     name = world_db["ThingTypes"][type]["TT_NAME"]
1461                     strong_write(io_db["file_out"], name + "\n")
1462             else:
1463                 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1464                               for mt in world_db["Things"][0]["T_MEMTHING"]
1465                               if mt[0] == tid if y == mt[1] if x == mt[2]]:
1466                     name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1467                     strong_write(io_db["file_out"], name + "\n")
1468             if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"):  # #
1469                 name = "(terrain: SEA)"  # #
1470             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."):  # #
1471                 name = "(terrain: EARTH)"  # #
1472             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"):  # #
1473                 name = "(terrain: SOIL)"  # #
1474             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"):  # #
1475                 name = "(terrain: TREE)"  # #
1476             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"):  # #
1477                 name = "(terrain: WALL)"  # #
1478             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"):  # #
1479                 name = "(terrain: ALTAR)"  # #
1480             else:  # #
1481                 name = "(?)"  # #
1482             strong_write(io_db["file_out"], name + "\n")  # #
1483             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1484         else:
1485             print("Ignoring: Invalid map coordinates.")
1486     else:
1487         print("Ignoring: Command only works on existing worlds.")
1488
1489
1490 def play_commander(action, args=False):
1491     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1492
1493     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1494     """
1495
1496     def set_command():
1497         id = [x for x in world_db["ThingActions"]
1498                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1499         world_db["Things"][0]["T_COMMAND"] = id
1500         turn_over()
1501
1502     def set_command_and_argument_int(str_arg):
1503         val = integer_test(str_arg, 0, 255)
1504         if None != val:
1505             world_db["Things"][0]["T_ARGUMENT"] = val
1506             set_command()
1507
1508     def set_command_and_argument_movestring(str_arg):
1509         if str_arg in directions_db:
1510             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1511             set_command()
1512         else:
1513             print("Ignoring: Argument must be valid direction string.")
1514
1515     if action == "move":
1516         return set_command_and_argument_movestring
1517     elif args:
1518         return set_command_and_argument_int
1519     else:
1520         return set_command
1521
1522
1523 def command_seedrandomness(seed_string):
1524     """Set rand seed to int(seed_string)."""
1525     val = integer_test(seed_string, 0, 4294967295)
1526     if None != val:
1527         rand.seed = val
1528
1529
1530 def command_makeworld(seed_string):
1531     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1532
1533     Seed rand with seed. Do more only with a "wait" ThingAction and
1534     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1535     world_db["Things"] emptied, call make_map() and set
1536     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1537     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1538     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1539     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1540     Call log_help().
1541     """
1542
1543     # def free_pos(plant=False):
1544     def free_pos(plant=False):  # #
1545         i = 0
1546         while 1:
1547             err = "Space to put thing on too hard to find. Map too small?"
1548             while 1:
1549                 y = rand.next() % world_db["MAP_LENGTH"]
1550                 x = rand.next() % world_db["MAP_LENGTH"]
1551                 pos = y * world_db["MAP_LENGTH"] + x;
1552                 if (not plant  # #
1553                     and "." == chr(world_db["MAP"][pos])) \
1554                    or ":" == chr(world_db["MAP"][pos]):  # #
1555                     break
1556                 i += 1
1557                 if i == 65535:
1558                     raise SystemExit(err)
1559             # Replica of C code, wrongly ignores animatedness of new Thing.
1560             pos_clear = (0 == len([id for id in world_db["Things"]
1561                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1562                                    if world_db["Things"][id]["T_POSY"] == y
1563                                    if world_db["Things"][id]["T_POSX"] == x]))
1564             if pos_clear:
1565                 break
1566         return (y, x)
1567
1568     val = integer_test(seed_string, 0, 4294967295)
1569     if None == val:
1570         return
1571     rand.seed = val
1572     player_will_be_generated = False
1573     playertype = world_db["PLAYER_TYPE"]
1574     for ThingType in world_db["ThingTypes"]:
1575         if playertype == ThingType:
1576             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1577                 player_will_be_generated = True
1578             break
1579     if not player_will_be_generated:
1580         print("Ignoring: No player type with start number >0 defined.")
1581         return
1582     wait_action = False
1583     for ThingAction in world_db["ThingActions"]:
1584         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1585             wait_action = True
1586     if not wait_action:
1587         print("Ignoring: No thing action with name 'wait' defined.")
1588         return
1589     for name in specials:  # #
1590         if world_db[name] not in world_db["ThingTypes"]:  # #
1591             print("Ignoring: No valid " + name + " set.")  # #
1592             return  # #
1593     world_db["Things"] = {}
1594     make_map()
1595     world_db["WORLD_ACTIVE"] = 1
1596     world_db["TURN"] = 1
1597     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1598         id = id_setter(-1, "Things")
1599         world_db["Things"][id] = new_Thing(playertype, free_pos())
1600     if not world_db["Things"][0]["fovmap"]:
1601         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1602         world_db["Things"][0]["fovmap"] = empty_fovmap
1603     update_map_memory(world_db["Things"][0])
1604     for type in world_db["ThingTypes"]:
1605         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1606             if type != playertype:
1607                 id = id_setter(-1, "Things")
1608                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1609                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1610     strong_write(io_db["file_out"], "NEW_WORLD\n")
1611     log_help()
1612
1613
1614 def command_maplength(maplength_string):
1615     """Redefine map length. Invalidate map, therefore lose all things on it."""
1616     val = integer_test(maplength_string, 1, 256)
1617     if None != val:
1618         world_db["MAP_LENGTH"] = val
1619         world_db["MAP"] = False
1620         set_world_inactive()
1621         world_db["Things"] = {}
1622         libpr.set_maplength(val)
1623
1624
1625 def command_worldactive(worldactive_string):
1626     """Toggle world_db["WORLD_ACTIVE"] if possible.
1627
1628     An active world can always be set inactive. An inactive world can only be
1629     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1630     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1631     Also call log_help().
1632     """
1633     # 7DRL: altar must be on map, and specials must be set for active world.
1634     val = integer_test(worldactive_string, 0, 1)
1635     if None != val:
1636         if 0 != world_db["WORLD_ACTIVE"]:
1637             if 0 == val:
1638                 set_world_inactive()
1639             else:
1640                 print("World already active.")
1641         elif 0 == world_db["WORLD_ACTIVE"]:
1642             wait_exists = False
1643             for ThingAction in world_db["ThingActions"]:
1644                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1645                     wait_exists = True
1646                     break
1647             player_exists = False
1648             for Thing in world_db["Things"]:
1649                 if 0 == Thing:
1650                     player_exists = True
1651                     break
1652             specials_set = True  # #
1653             for name in specials:  # #
1654                 if world_db[name] not in world_db["ThingTypes"]:  # #
1655                     specials_set = False  # #
1656             altar_found = False  # #
1657             if world_db["MAP"]:  # #
1658                 pos = world_db["MAP"].find(b'_')  # #
1659                 if pos > 0:  # #
1660                     y = int(pos / world_db["MAP_LENGTH"])  # #
1661                     x = pos % world_db["MAP_LENGTH"]  # #
1662                     world_db["altar"] = (y, x)  # #
1663                     altar_found = True  # #
1664             if wait_exists and player_exists and world_db["MAP"] \
1665                and specials_set:  # #
1666                 for id in world_db["Things"]:
1667                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1668                         build_fov_map(world_db["Things"][id])
1669                         if 0 == id:
1670                             update_map_memory(world_db["Things"][id], False)
1671                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1672                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1673                     world_db["Things"][0]["fovmap"] = empty_fovmap
1674                 world_db["WORLD_ACTIVE"] = 1
1675                 log_help()
1676             else:
1677                 print("Ignoring: Not all conditions for world activation met.")
1678
1679
1680 def specialtypesetter(name):  # #
1681     """Setter world_db[name], deactivating world if set int no ThingType."""
1682     def helper(str_int):
1683         val = integer_test(str_int, 0)
1684         if None != val:
1685             world_db[name] = val
1686             if world_db["WORLD_ACTIVE"] \
1687                and world_db[name] not in world_db["ThingTypes"]:
1688                 world_db["WORLD_ACTIVE"] = 0
1689                 print(name + " fits no known ThingType, deactivating world.")
1690     return helper
1691
1692
1693 def test_for_id_maker(object, category):
1694     """Return decorator testing for object having "id" attribute."""
1695     def decorator(f):
1696         def helper(*args):
1697             if hasattr(object, "id"):
1698                 f(*args)
1699             else:
1700                 print("Ignoring: No " + category +
1701                       " defined to manipulate yet.")
1702         return helper
1703     return decorator
1704
1705
1706 def command_tid(id_string):
1707     """Set ID of Thing to manipulate. ID unused? Create new one.
1708
1709     Default new Thing's type to the first available ThingType, others: zero.
1710     """
1711     id = id_setter(id_string, "Things", command_tid)
1712     if None != id:
1713         if world_db["ThingTypes"] == {}:
1714             print("Ignoring: No ThingType to settle new Thing in.")
1715             return
1716         type = list(world_db["ThingTypes"].keys())[0]
1717         world_db["Things"][id] = new_Thing(type)
1718
1719
1720 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1721
1722
1723 @test_Thing_id
1724 def command_tcommand(str_int):
1725     """Set T_COMMAND of selected Thing."""
1726     val = integer_test(str_int, 0)
1727     if None != val:
1728         if 0 == val or val in world_db["ThingActions"]:
1729             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1730         else:
1731             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1732
1733
1734 @test_Thing_id
1735 def command_ttype(str_int):
1736     """Set T_TYPE of selected Thing."""
1737     val = integer_test(str_int, 0)
1738     if None != val:
1739         if val in world_db["ThingTypes"]:
1740             world_db["Things"][command_tid.id]["T_TYPE"] = val
1741         else:
1742             print("Ignoring: ThingType ID belongs to no known ThingType.")
1743
1744
1745 @test_Thing_id
1746 def command_tcarries(str_int):
1747     """Append int(str_int) to T_CARRIES of selected Thing.
1748
1749     The ID int(str_int) must not be of the selected Thing, and must belong to a
1750     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1751     """
1752     val = integer_test(str_int, 0)
1753     if None != val:
1754         if val == command_tid.id:
1755             print("Ignoring: Thing cannot carry itself.")
1756         elif val in world_db["Things"] \
1757              and not world_db["Things"][val]["carried"]:
1758             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1759             world_db["Things"][val]["carried"] = True
1760         else:
1761             print("Ignoring: Thing not available for carrying.")
1762     # Note that the whole carrying structure is different from the C version:
1763     # Carried-ness is marked by a "carried" flag, not by Things containing
1764     # Things internally.
1765
1766
1767 @test_Thing_id
1768 def command_tmemthing(str_t, str_y, str_x):
1769     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1770
1771     The type must fit to an existing ThingType, and the position into the map.
1772     """
1773     type = integer_test(str_t, 0)
1774     posy = integer_test(str_y, 0, 255)
1775     posx = integer_test(str_x, 0, 255)
1776     if None != type and None != posy and None != posx:
1777         if type not in world_db["ThingTypes"] \
1778            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1779             print("Ignoring: Illegal value for thing type or position.")
1780         else:
1781             memthing = (type, posy, posx)
1782             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1783
1784
1785 def setter_map(maptype):
1786     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1787
1788     If no map of maptype exists yet, initialize it with ' ' bytes first.
1789     """
1790
1791     def valid_map_line(str_int, mapline):
1792         val = integer_test(str_int, 0, 255)
1793         if None != val:
1794             if val >= world_db["MAP_LENGTH"]:
1795                 print("Illegal value for map line number.")
1796             elif len(mapline) != world_db["MAP_LENGTH"]:
1797                 print("Map line length is unequal map width.")
1798             else:
1799                 return val
1800         return None
1801
1802     def nonThingMap_helper(str_int, mapline):
1803         val = valid_map_line(str_int, mapline)
1804         if None != val:
1805             length = world_db["MAP_LENGTH"]
1806             if not world_db["MAP"]:
1807                 map = bytearray(b' ' * (length ** 2))
1808             else:
1809                 map = world_db["MAP"]
1810             map[val * length:(val * length) + length] = mapline.encode()
1811             if not world_db["MAP"]:
1812                 world_db["MAP"] = map
1813
1814     @test_Thing_id
1815     def ThingMap_helper(str_int, mapline):
1816         val = valid_map_line(str_int, mapline)
1817         if None != val:
1818             length = world_db["MAP_LENGTH"]
1819             if not world_db["Things"][command_tid.id][maptype]:
1820                 map = bytearray(b' ' * (length ** 2))
1821             else:
1822                 map = world_db["Things"][command_tid.id][maptype]
1823             map[val * length:(val * length) + length] = mapline.encode()
1824             if not world_db["Things"][command_tid.id][maptype]:
1825                 world_db["Things"][command_tid.id][maptype] = map
1826
1827     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1828
1829
1830 def setter_tpos(axis):
1831     """Generate setter for T_POSX or  T_POSY of selected Thing.
1832
1833     If world is active, rebuilds animate things' fovmap, player's memory map.
1834     """
1835     @test_Thing_id
1836     def helper(str_int):
1837         val = integer_test(str_int, 0, 255)
1838         if None != val:
1839             if val < world_db["MAP_LENGTH"]:
1840                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1841                 if world_db["WORLD_ACTIVE"] \
1842                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1843                     build_fov_map(world_db["Things"][command_tid.id])
1844                     if 0 == command_tid.id:
1845                         update_map_memory(world_db["Things"][command_tid.id])
1846             else:
1847                 print("Ignoring: Position is outside of map.")
1848     return helper
1849
1850
1851 def command_ttid(id_string):
1852     """Set ID of ThingType to manipulate. ID unused? Create new one.
1853
1854     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1855     "", others: 0.
1856     """
1857     id = id_setter(id_string, "ThingTypes", command_ttid)
1858     if None != id:
1859         world_db["ThingTypes"][id] = {
1860             "TT_NAME": "(none)",
1861             "TT_TOOLPOWER": 0,
1862             "TT_LIFEPOINTS": 0,
1863             "TT_PROLIFERATE": 0,
1864             "TT_START_NUMBER": 0,
1865             "TT_STORAGE": 0, # #
1866             "TT_SYMBOL": "?",
1867             "TT_CORPSE_ID": id,
1868             "TT_TOOL": ""
1869         }
1870
1871
1872 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1873
1874
1875 @test_ThingType_id
1876 def command_ttname(name):
1877     """Set TT_NAME of selected ThingType."""
1878     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1879
1880
1881 @test_ThingType_id
1882 def command_tttool(name):
1883     """Set TT_TOOL of selected ThingType."""
1884     world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1885
1886
1887 @test_ThingType_id
1888 def command_ttsymbol(char):
1889     """Set TT_SYMBOL of selected ThingType. """
1890     if 1 == len(char):
1891         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1892     else:
1893         print("Ignoring: Argument must be single character.")
1894
1895
1896 @test_ThingType_id
1897 def command_ttcorpseid(str_int):
1898     """Set TT_CORPSE_ID of selected ThingType."""
1899     val = integer_test(str_int, 0)
1900     if None != val:
1901         if val in world_db["ThingTypes"]:
1902             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1903         else:
1904             print("Ignoring: Corpse ID belongs to no known ThignType.")
1905
1906
1907 def command_taid(id_string):
1908     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1909
1910     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1911     """
1912     id = id_setter(id_string, "ThingActions", command_taid, True)
1913     if None != id:
1914         world_db["ThingActions"][id] = {
1915             "TA_EFFORT": 1,
1916             "TA_NAME": "wait"
1917         }
1918
1919
1920 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1921
1922
1923 @test_ThingAction_id
1924 def command_taname(name):
1925     """Set TA_NAME of selected ThingAction.
1926
1927     The name must match a valid thing action function. If after the name
1928     setting no ThingAction with name "wait" remains, call set_world_inactive().
1929     """
1930     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1931        or name == "pick_up":
1932         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1933         if 1 == world_db["WORLD_ACTIVE"]:
1934             wait_defined = False
1935             for id in world_db["ThingActions"]:
1936                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1937                     wait_defined = True
1938                     break
1939             if not wait_defined:
1940                 set_world_inactive()
1941     else:
1942         print("Ignoring: Invalid action name.")
1943     # In contrast to the original,naming won't map a function to a ThingAction.
1944
1945
1946 def command_ai():
1947     """Call ai() on player Thing, then turn_over()."""
1948     ai(world_db["Things"][0])
1949     turn_over()
1950
1951
1952 """Commands database.
1953
1954 Map command start tokens to ([0]) number of expected command arguments, ([1])
1955 the command's meta-ness (i.e. is it to be written to the record file, is it to
1956 be ignored in replay mode if read from server input file), and ([2]) a function
1957 to be called on it.
1958 """
1959 commands_db = {
1960     "QUIT": (0, True, command_quit),
1961     "PING": (0, True, command_ping),
1962     "THINGS_HERE": (2, True, command_thingshere),
1963     "MAKE_WORLD": (1, False, command_makeworld),
1964     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1965     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1966     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
1967     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
1968     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
1969     "MAP_LENGTH": (1, False, command_maplength),
1970     "WORLD_ACTIVE": (1, False, command_worldactive),
1971     "MAP": (2, False, setter_map("MAP")),
1972     "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)),  # #
1973     "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")),  # #
1974     "PLANT_0": (1, False, specialtypesetter("PLANT_0")),  # #
1975     "PLANT_1": (1, False, specialtypesetter("PLANT_1")),  # #
1976     "LUMBER": (1, False, specialtypesetter("LUMBER")),  # #
1977     "TOOL_0": (1, False, specialtypesetter("TOOL_0")),  # #
1978     "TA_ID": (1, False, command_taid),
1979     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
1980     "TA_NAME": (1, False, command_taname),
1981     "TT_ID": (1, False, command_ttid),
1982     "TT_NAME": (1, False, command_ttname),
1983     "TT_TOOL": (1, False, command_tttool),
1984     "TT_SYMBOL": (1, False, command_ttsymbol),
1985     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
1986     "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
1987     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
1988                                          0, 255)),
1989     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
1990                                         0, 65535)),
1991     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
1992     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
1993     "T_ID": (1, False, command_tid),
1994     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
1995     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
1996     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
1997     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
1998     "T_COMMAND": (1, False, command_tcommand),
1999     "T_TYPE": (1, False, command_ttype),
2000     "T_CARRIES": (1, False, command_tcarries),
2001     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2002     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2003     "T_MEMTHING": (3, False, command_tmemthing),
2004     "T_POSY": (1, False, setter_tpos("Y")),
2005     "T_POSX": (1, False, setter_tpos("X")),
2006     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
2007     "wait": (0, False, play_commander("wait")),
2008     "move": (1, False, play_commander("move")),
2009     "pick_up": (0, False, play_commander("pick_up")),
2010     "drop": (1, False, play_commander("drop", True)),
2011     "use": (1, False, play_commander("use", True)),
2012     "ai": (0, False, command_ai)
2013 }
2014 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2015
2016
2017 """World state database. With sane default values. (Randomness is in rand.)"""
2018 world_db = {
2019     "TURN": 0,
2020     "MAP_LENGTH": 64,
2021     "PLAYER_TYPE": 0,
2022     "WORLD_ACTIVE": 0,
2023     "GOD_MOOD": 0,  # #
2024     "GOD_FAVOR": 0,  # #
2025     "MAP": False,
2026     "FAVOR_STAGE": 0,  # #
2027     "SLIPPERS": 0,  # #
2028     "PLANT_0": 0,  # #
2029     "PLANT_1": 0,  # #
2030     "LUMBER": 0,  # #
2031     "TOOL_0": 0,  # #
2032     "ThingActions": {},
2033     "ThingTypes": {},
2034     "Things": {}
2035 }
2036
2037 # 7DRL-specific!
2038 """Special type settings."""
2039 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"]  # #
2040
2041 """Mapping of direction names to internal direction chars."""
2042 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2043                  "west": "s", "north-west": "w", "north-east": "e"}
2044
2045 """File IO database."""
2046 io_db = {
2047     "path_save": "save",
2048     "path_record": "record_save",
2049     "path_worldconf": "confserver/world",
2050     "path_server": "server/",
2051     "path_in": "server/in",
2052     "path_out": "server/out",
2053     "path_worldstate": "server/worldstate",
2054     "tmp_suffix": "_tmp",
2055     "kicked_by_rival": False,
2056     "worldstate_updateable": False
2057 }
2058
2059
2060 try:
2061     libpr = prep_library()
2062     rand = RandomnessIO()
2063     opts = parse_command_line_arguments()
2064     if opts.savefile:
2065         io_db["path_save"] = opts.savefile
2066         io_db["path_record"] = "record_" + opts.savefile
2067     setup_server_io()
2068     if opts.verbose:
2069         io_db["verbose"] = True
2070     if None != opts.replay:
2071         replay_game()
2072     else:
2073         play_game()
2074 except SystemExit as exit:
2075     print("ABORTING: " + exit.args[0])
2076 except:
2077     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
2078     raise
2079 finally:
2080     cleanup_server_io()