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