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