home · contact · privacy
29fe11994b79c15bca1ac95536f788cb16345e21
[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 not world_db["Things"][id]["carried"]
1304                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1305                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1306                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1307                   ["TT_TOOL"] == "food"]:
1308         return True
1309     return False
1310
1311
1312 def get_inventory_slot_to_consume(t):
1313     """Return slot Id of healthiest consumable in t's inventory, else -1."""
1314     cmp_food = -1
1315     selection = -1
1316     i = 0
1317     for id in t["T_CARRIES"]:
1318         type = world_db["Things"][id]["T_TYPE"]
1319         if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1320            and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
1321             nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1322             tmp_cmp = abs(t["T_SATIATION"] + nutvalue)
1323             if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1324             or tmp_cmp < cmp_food:
1325                 cmp_food = tmp_cmp
1326                 selection = i
1327         i += 1
1328     return selection
1329
1330
1331 def ai(t):
1332     """Determine next command/argment for actor t via AI algorithms.
1333
1334     AI will look for, and move towards, enemies (animate Things not of their
1335     own ThingType); if they see none, they will consume consumables in their
1336     inventory; if there are none, they will pick up what they stand on if they
1337     stand on consumables; if they stand on none, they will move towards the
1338     next consumable they see or remember on the map; if they see or remember
1339     none, they will explore parts of the map unseen since ever or for at least
1340     one turn; if there is nothing to explore, they will simply wait.
1341     """
1342     # 7DRL add: Don't pick up or search things when inventory is full.
1343     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1344                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1345     if not get_dir_to_target(t, "f"):
1346         sel = get_inventory_slot_to_consume(t)
1347         if -1 != sel:
1348             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1349                               if world_db["ThingActions"][id]["TA_NAME"]
1350                                  == "use"][0]
1351             t["T_ARGUMENT"] = sel
1352         elif standing_on_food(t) \
1353              and (len(t["T_CARRIES"]) < # #
1354                  world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1355             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1356                               if world_db["ThingActions"][id]["TA_NAME"]
1357                                  == "pick_up"][0]
1358         elif (not
1359               (len(t["T_CARRIES"]) < # #
1360                 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1361                and get_dir_to_target(t, "c"))) and \
1362              (not get_dir_to_target(t, "a")):
1363             get_dir_to_target(t, "s")
1364
1365
1366 def turn_over():
1367     """Run game world and its inhabitants until new player input expected."""
1368     id = 0
1369     whilebreaker = False
1370     while world_db["Things"][0]["T_LIFEPOINTS"]:
1371         proliferable_map = world_db["MAP"][:]
1372         for id in [id for id in world_db["Things"]
1373                    if not world_db["Things"][id]["carried"]]:
1374             y = world_db["Things"][id]["T_POSY"]
1375             x = world_db["Things"][id]["T_POSX"]
1376             proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1377         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1378             if not id in world_db["Things"] or \
1379                world_db["Things"][id]["carried"]:   # May have been consumed or
1380                 continue                            # picked up during turn …
1381             Thing = world_db["Things"][id]
1382             if Thing["T_LIFEPOINTS"]:
1383                 if not Thing["T_COMMAND"]:
1384                     update_map_memory(Thing)
1385                     if 0 == id:
1386                         whilebreaker = True
1387                         break
1388                     ai(Thing)
1389                 try_healing(Thing)
1390                 hunger(Thing)
1391                 if Thing["T_LIFEPOINTS"]:
1392                     Thing["T_PROGRESS"] += 1
1393                     taid = [a for a in world_db["ThingActions"]
1394                               if a == Thing["T_COMMAND"]][0]
1395                     ThingAction = world_db["ThingActions"][taid]
1396                     if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1397                         eval("actor_" + ThingAction["TA_NAME"])(Thing)
1398                         Thing["T_COMMAND"] = 0
1399                         Thing["T_PROGRESS"] = 0
1400             thingproliferation(Thing, proliferable_map)
1401         if whilebreaker:
1402             break
1403         world_db["TURN"] += 1
1404
1405
1406 def new_Thing(type, pos=(0, 0)):
1407     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1408     thing = {
1409         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1410         "T_ARGUMENT": 0,
1411         "T_PROGRESS": 0,
1412         "T_SATIATION": 0,
1413         "T_COMMAND": 0,
1414         "T_PLAYERDROP": 0,  # #
1415         "T_TYPE": type,
1416         "T_POSY": pos[0],
1417         "T_POSX": pos[1],
1418         "T_CARRIES": [],
1419         "carried": False,
1420         "T_MEMTHING": [],
1421         "T_MEMMAP": False,
1422         "T_MEMDEPTHMAP": False,
1423         "fovmap": False
1424     }
1425     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1426         build_fov_map(thing)
1427     return thing
1428
1429
1430 def id_setter(id, category, id_store=False, start_at_1=False):
1431     """Set ID of object of category to manipulate ID unused? Create new one.
1432
1433     The ID is stored as id_store.id (if id_store is set). If the integer of the
1434     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1435     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1436     always returned when no new object is created, otherwise the new object's
1437     ID.
1438     """
1439     min = 0 if start_at_1 else -1
1440     if str == type(id):
1441         id = integer_test(id, min)
1442     if None != id:
1443         if id in world_db[category]:
1444             if id_store:
1445                 id_store.id = id
1446             return None
1447         else:
1448             if (start_at_1 and 0 == id) \
1449                or ((not start_at_1) and (id < 0)):
1450                 id = 0 if start_at_1 else -1
1451                 while 1:
1452                     id = id + 1
1453                     if id not in world_db[category]:
1454                         break
1455             if id_store:
1456                 id_store.id = id
1457     return id
1458
1459
1460 def command_ping():
1461     """Send PONG line to server output file."""
1462     strong_write(io_db["file_out"], "PONG\n")
1463
1464
1465 def command_quit():
1466     """Abort server process."""
1467     if None == opts.replay:
1468         if world_db["WORLD_ACTIVE"]:
1469             save_world()
1470         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1471     raise SystemExit("received QUIT command")
1472
1473
1474 def command_thingshere(str_y, str_x):
1475     """Write to out file list of Things known to player at coordinate y, x."""
1476     # 7DRL: terrain, too
1477     if world_db["WORLD_ACTIVE"]:
1478         y = integer_test(str_y, 0, 255)
1479         x = integer_test(str_x, 0, 255)
1480         length = world_db["MAP_LENGTH"]
1481         if None != y and None != x and y < length and x < length:
1482             pos = (y * world_db["MAP_LENGTH"]) + x
1483             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1484             pos = y * world_db["MAP_LENGTH"] + x;  # #
1485             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1486                 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1487                               for id in world_db["Things"]
1488                               if not world_db["Things"][id]["carried"]
1489                               if world_db["Things"][id]["T_TYPE"] == tid
1490                               if y == world_db["Things"][id]["T_POSY"]
1491                               if x == world_db["Things"][id]["T_POSX"]]:
1492                     type = world_db["Things"][id]["T_TYPE"]
1493                     name = world_db["ThingTypes"][type]["TT_NAME"]
1494                     strong_write(io_db["file_out"], name + "\n")
1495             else:
1496                 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1497                               for mt in world_db["Things"][0]["T_MEMTHING"]
1498                               if mt[0] == tid if y == mt[1] if x == mt[2]]:
1499                     name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1500                     strong_write(io_db["file_out"], name + "\n")
1501             if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"):  # #
1502                 name = "(terrain: SEA)"  # #
1503             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."):  # #
1504                 name = "(terrain: EARTH)"  # #
1505             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"):  # #
1506                 name = "(terrain: SOIL)"  # #
1507             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"):  # #
1508                 name = "(terrain: TREE)"  # #
1509             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"):  # #
1510                 name = "(terrain: WALL)"  # #
1511             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"):  # #
1512                 name = "(terrain: ALTAR)"  # #
1513             else:  # #
1514                 name = "(?)"  # #
1515             strong_write(io_db["file_out"], name + "\n")  # #
1516             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1517         else:
1518             print("Ignoring: Invalid map coordinates.")
1519     else:
1520         print("Ignoring: Command only works on existing worlds.")
1521
1522
1523 def play_commander(action, args=False):
1524     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1525
1526     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1527     """
1528
1529     def set_command():
1530         id = [x for x in world_db["ThingActions"]
1531                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1532         world_db["Things"][0]["T_COMMAND"] = id
1533         turn_over()
1534
1535     def set_command_and_argument_int(str_arg):
1536         val = integer_test(str_arg, 0, 255)
1537         if None != val:
1538             world_db["Things"][0]["T_ARGUMENT"] = val
1539             set_command()
1540
1541     def set_command_and_argument_movestring(str_arg):
1542         if str_arg in directions_db:
1543             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1544             set_command()
1545         else:
1546             print("Ignoring: Argument must be valid direction string.")
1547
1548     if action == "move":
1549         return set_command_and_argument_movestring
1550     elif args:
1551         return set_command_and_argument_int
1552     else:
1553         return set_command
1554
1555
1556 def command_seedrandomness(seed_string):
1557     """Set rand seed to int(seed_string)."""
1558     val = integer_test(seed_string, 0, 4294967295)
1559     if None != val:
1560         rand.seed = val
1561
1562
1563 def command_makeworld(seed_string):
1564     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1565
1566     Seed rand with seed. Do more only with a "wait" ThingAction and
1567     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1568     world_db["Things"] emptied, call make_map() and set
1569     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1570     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1571     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1572     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1573     Call log_help().
1574     """
1575
1576     # def free_pos(plant=False):
1577     def free_pos(plant=False):  # #
1578         i = 0
1579         while 1:
1580             err = "Space to put thing on too hard to find. Map too small?"
1581             while 1:
1582                 y = rand.next() % world_db["MAP_LENGTH"]
1583                 x = rand.next() % world_db["MAP_LENGTH"]
1584                 pos = y * world_db["MAP_LENGTH"] + x;
1585                 if (not plant  # #
1586                     and "." == chr(world_db["MAP"][pos])) \
1587                    or ":" == chr(world_db["MAP"][pos]):  # #
1588                     break
1589                 i += 1
1590                 if i == 65535:
1591                     raise SystemExit(err)
1592             # Replica of C code, wrongly ignores animatedness of new Thing.
1593             pos_clear = (0 == len([id for id in world_db["Things"]
1594                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1595                                    if world_db["Things"][id]["T_POSY"] == y
1596                                    if world_db["Things"][id]["T_POSX"] == x]))
1597             if pos_clear:
1598                 break
1599         return (y, x)
1600
1601     val = integer_test(seed_string, 0, 4294967295)
1602     if None == val:
1603         return
1604     rand.seed = val
1605     player_will_be_generated = False
1606     playertype = world_db["PLAYER_TYPE"]
1607     for ThingType in world_db["ThingTypes"]:
1608         if playertype == ThingType:
1609             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1610                 player_will_be_generated = True
1611             break
1612     if not player_will_be_generated:
1613         print("Ignoring: No player type with start number >0 defined.")
1614         return
1615     wait_action = False
1616     for ThingAction in world_db["ThingActions"]:
1617         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1618             wait_action = True
1619     if not wait_action:
1620         print("Ignoring: No thing action with name 'wait' defined.")
1621         return
1622     for name in specials:  # #
1623         if world_db[name] not in world_db["ThingTypes"]:  # #
1624             print("Ignoring: No valid " + name + " set.")  # #
1625             return  # #
1626     world_db["Things"] = {}
1627     make_map()
1628     world_db["WORLD_ACTIVE"] = 1
1629     world_db["TURN"] = 1
1630     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1631         id = id_setter(-1, "Things")
1632         world_db["Things"][id] = new_Thing(playertype, free_pos())
1633     if not world_db["Things"][0]["fovmap"]:
1634         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1635         world_db["Things"][0]["fovmap"] = empty_fovmap
1636     update_map_memory(world_db["Things"][0])
1637     for type in world_db["ThingTypes"]:
1638         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1639             if type != playertype:
1640                 id = id_setter(-1, "Things")
1641                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1642                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1643     strong_write(io_db["file_out"], "NEW_WORLD\n")
1644     log_help()
1645
1646
1647 def command_maplength(maplength_string):
1648     """Redefine map length. Invalidate map, therefore lose all things on it."""
1649     val = integer_test(maplength_string, 1, 256)
1650     if None != val:
1651         world_db["MAP_LENGTH"] = val
1652         world_db["MAP"] = False
1653         set_world_inactive()
1654         world_db["Things"] = {}
1655         libpr.set_maplength(val)
1656
1657
1658 def command_worldactive(worldactive_string):
1659     """Toggle world_db["WORLD_ACTIVE"] if possible.
1660
1661     An active world can always be set inactive. An inactive world can only be
1662     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1663     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1664     Also call log_help().
1665     """
1666     # 7DRL: altar must be on map, and specials must be set for active world.
1667     val = integer_test(worldactive_string, 0, 1)
1668     if None != val:
1669         if 0 != world_db["WORLD_ACTIVE"]:
1670             if 0 == val:
1671                 set_world_inactive()
1672             else:
1673                 print("World already active.")
1674         elif 0 == world_db["WORLD_ACTIVE"]:
1675             wait_exists = False
1676             for ThingAction in world_db["ThingActions"]:
1677                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1678                     wait_exists = True
1679                     break
1680             player_exists = False
1681             for Thing in world_db["Things"]:
1682                 if 0 == Thing:
1683                     player_exists = True
1684                     break
1685             specials_set = True  # #
1686             for name in specials:  # #
1687                 if world_db[name] not in world_db["ThingTypes"]:  # #
1688                     specials_set = False  # #
1689             altar_found = False  # #
1690             if world_db["MAP"]:  # #
1691                 pos = world_db["MAP"].find(b'_')  # #
1692                 if pos > 0:  # #
1693                     y = int(pos / world_db["MAP_LENGTH"])  # #
1694                     x = pos % world_db["MAP_LENGTH"]  # #
1695                     world_db["altar"] = (y, x)  # #
1696                     altar_found = True  # #
1697             if wait_exists and player_exists and world_db["MAP"] \
1698                and specials_set:  # #
1699                 for id in world_db["Things"]:
1700                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1701                         build_fov_map(world_db["Things"][id])
1702                         if 0 == id:
1703                             update_map_memory(world_db["Things"][id], False)
1704                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1705                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1706                     world_db["Things"][0]["fovmap"] = empty_fovmap
1707                 world_db["WORLD_ACTIVE"] = 1
1708                 log_help()
1709             else:
1710                 print("Ignoring: Not all conditions for world activation met.")
1711
1712
1713 def specialtypesetter(name):  # #
1714     """Setter world_db[name], deactivating world if set int no ThingType."""
1715     def helper(str_int):
1716         val = integer_test(str_int, 0)
1717         if None != val:
1718             world_db[name] = val
1719             if world_db["WORLD_ACTIVE"] \
1720                and world_db[name] not in world_db["ThingTypes"]:
1721                 world_db["WORLD_ACTIVE"] = 0
1722                 print(name + " fits no known ThingType, deactivating world.")
1723     return helper
1724
1725
1726 def test_for_id_maker(object, category):
1727     """Return decorator testing for object having "id" attribute."""
1728     def decorator(f):
1729         def helper(*args):
1730             if hasattr(object, "id"):
1731                 f(*args)
1732             else:
1733                 print("Ignoring: No " + category +
1734                       " defined to manipulate yet.")
1735         return helper
1736     return decorator
1737
1738
1739 def command_tid(id_string):
1740     """Set ID of Thing to manipulate. ID unused? Create new one.
1741
1742     Default new Thing's type to the first available ThingType, others: zero.
1743     """
1744     id = id_setter(id_string, "Things", command_tid)
1745     if None != id:
1746         if world_db["ThingTypes"] == {}:
1747             print("Ignoring: No ThingType to settle new Thing in.")
1748             return
1749         type = list(world_db["ThingTypes"].keys())[0]
1750         world_db["Things"][id] = new_Thing(type)
1751
1752
1753 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1754
1755
1756 @test_Thing_id
1757 def command_tcommand(str_int):
1758     """Set T_COMMAND of selected Thing."""
1759     val = integer_test(str_int, 0)
1760     if None != val:
1761         if 0 == val or val in world_db["ThingActions"]:
1762             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1763         else:
1764             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1765
1766
1767 @test_Thing_id
1768 def command_ttype(str_int):
1769     """Set T_TYPE of selected Thing."""
1770     val = integer_test(str_int, 0)
1771     if None != val:
1772         if val in world_db["ThingTypes"]:
1773             world_db["Things"][command_tid.id]["T_TYPE"] = val
1774         else:
1775             print("Ignoring: ThingType ID belongs to no known ThingType.")
1776
1777
1778 @test_Thing_id
1779 def command_tcarries(str_int):
1780     """Append int(str_int) to T_CARRIES of selected Thing.
1781
1782     The ID int(str_int) must not be of the selected Thing, and must belong to a
1783     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1784     """
1785     val = integer_test(str_int, 0)
1786     if None != val:
1787         if val == command_tid.id:
1788             print("Ignoring: Thing cannot carry itself.")
1789         elif val in world_db["Things"] \
1790              and not world_db["Things"][val]["carried"]:
1791             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1792             world_db["Things"][val]["carried"] = True
1793         else:
1794             print("Ignoring: Thing not available for carrying.")
1795     # Note that the whole carrying structure is different from the C version:
1796     # Carried-ness is marked by a "carried" flag, not by Things containing
1797     # Things internally.
1798
1799
1800 @test_Thing_id
1801 def command_tmemthing(str_t, str_y, str_x):
1802     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1803
1804     The type must fit to an existing ThingType, and the position into the map.
1805     """
1806     type = integer_test(str_t, 0)
1807     posy = integer_test(str_y, 0, 255)
1808     posx = integer_test(str_x, 0, 255)
1809     if None != type and None != posy and None != posx:
1810         if type not in world_db["ThingTypes"] \
1811            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1812             print("Ignoring: Illegal value for thing type or position.")
1813         else:
1814             memthing = (type, posy, posx)
1815             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1816
1817
1818 def setter_map(maptype):
1819     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1820
1821     If no map of maptype exists yet, initialize it with ' ' bytes first.
1822     """
1823
1824     def valid_map_line(str_int, mapline):
1825         val = integer_test(str_int, 0, 255)
1826         if None != val:
1827             if val >= world_db["MAP_LENGTH"]:
1828                 print("Illegal value for map line number.")
1829             elif len(mapline) != world_db["MAP_LENGTH"]:
1830                 print("Map line length is unequal map width.")
1831             else:
1832                 return val
1833         return None
1834
1835     def nonThingMap_helper(str_int, mapline):
1836         val = valid_map_line(str_int, mapline)
1837         if None != val:
1838             length = world_db["MAP_LENGTH"]
1839             if not world_db["MAP"]:
1840                 map = bytearray(b' ' * (length ** 2))
1841             else:
1842                 map = world_db["MAP"]
1843             map[val * length:(val * length) + length] = mapline.encode()
1844             if not world_db["MAP"]:
1845                 world_db["MAP"] = map
1846
1847     @test_Thing_id
1848     def ThingMap_helper(str_int, mapline):
1849         val = valid_map_line(str_int, mapline)
1850         if None != val:
1851             length = world_db["MAP_LENGTH"]
1852             if not world_db["Things"][command_tid.id][maptype]:
1853                 map = bytearray(b' ' * (length ** 2))
1854             else:
1855                 map = world_db["Things"][command_tid.id][maptype]
1856             map[val * length:(val * length) + length] = mapline.encode()
1857             if not world_db["Things"][command_tid.id][maptype]:
1858                 world_db["Things"][command_tid.id][maptype] = map
1859
1860     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1861
1862
1863 def setter_tpos(axis):
1864     """Generate setter for T_POSX or  T_POSY of selected Thing.
1865
1866     If world is active, rebuilds animate things' fovmap, player's memory map.
1867     """
1868     @test_Thing_id
1869     def helper(str_int):
1870         val = integer_test(str_int, 0, 255)
1871         if None != val:
1872             if val < world_db["MAP_LENGTH"]:
1873                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1874                 if world_db["WORLD_ACTIVE"] \
1875                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1876                     build_fov_map(world_db["Things"][command_tid.id])
1877                     if 0 == command_tid.id:
1878                         update_map_memory(world_db["Things"][command_tid.id])
1879             else:
1880                 print("Ignoring: Position is outside of map.")
1881     return helper
1882
1883
1884 def command_ttid(id_string):
1885     """Set ID of ThingType to manipulate. ID unused? Create new one.
1886
1887     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1888     "", others: 0.
1889     """
1890     id = id_setter(id_string, "ThingTypes", command_ttid)
1891     if None != id:
1892         world_db["ThingTypes"][id] = {
1893             "TT_NAME": "(none)",
1894             "TT_TOOLPOWER": 0,
1895             "TT_LIFEPOINTS": 0,
1896             "TT_PROLIFERATE": 0,
1897             "TT_START_NUMBER": 0,
1898             "TT_STORAGE": 0, # #
1899             "TT_SYMBOL": "?",
1900             "TT_CORPSE_ID": id,
1901             "TT_TOOL": ""
1902         }
1903
1904
1905 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1906
1907
1908 @test_ThingType_id
1909 def command_ttname(name):
1910     """Set TT_NAME of selected ThingType."""
1911     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1912
1913
1914 @test_ThingType_id
1915 def command_tttool(name):
1916     """Set TT_TOOL of selected ThingType."""
1917     world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1918
1919
1920 @test_ThingType_id
1921 def command_ttsymbol(char):
1922     """Set TT_SYMBOL of selected ThingType. """
1923     if 1 == len(char):
1924         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1925     else:
1926         print("Ignoring: Argument must be single character.")
1927
1928
1929 @test_ThingType_id
1930 def command_ttcorpseid(str_int):
1931     """Set TT_CORPSE_ID of selected ThingType."""
1932     val = integer_test(str_int, 0)
1933     if None != val:
1934         if val in world_db["ThingTypes"]:
1935             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1936         else:
1937             print("Ignoring: Corpse ID belongs to no known ThignType.")
1938
1939
1940 def command_taid(id_string):
1941     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1942
1943     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1944     """
1945     id = id_setter(id_string, "ThingActions", command_taid, True)
1946     if None != id:
1947         world_db["ThingActions"][id] = {
1948             "TA_EFFORT": 1,
1949             "TA_NAME": "wait"
1950         }
1951
1952
1953 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1954
1955
1956 @test_ThingAction_id
1957 def command_taname(name):
1958     """Set TA_NAME of selected ThingAction.
1959
1960     The name must match a valid thing action function. If after the name
1961     setting no ThingAction with name "wait" remains, call set_world_inactive().
1962     """
1963     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1964        or name == "pick_up":
1965         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1966         if 1 == world_db["WORLD_ACTIVE"]:
1967             wait_defined = False
1968             for id in world_db["ThingActions"]:
1969                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1970                     wait_defined = True
1971                     break
1972             if not wait_defined:
1973                 set_world_inactive()
1974     else:
1975         print("Ignoring: Invalid action name.")
1976     # In contrast to the original,naming won't map a function to a ThingAction.
1977
1978
1979 def command_ai():
1980     """Call ai() on player Thing, then turn_over()."""
1981     ai(world_db["Things"][0])
1982     turn_over()
1983
1984
1985 """Commands database.
1986
1987 Map command start tokens to ([0]) number of expected command arguments, ([1])
1988 the command's meta-ness (i.e. is it to be written to the record file, is it to
1989 be ignored in replay mode if read from server input file), and ([2]) a function
1990 to be called on it.
1991 """
1992 commands_db = {
1993     "QUIT": (0, True, command_quit),
1994     "PING": (0, True, command_ping),
1995     "THINGS_HERE": (2, True, command_thingshere),
1996     "MAKE_WORLD": (1, False, command_makeworld),
1997     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
1998     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
1999     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
2000     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
2001     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
2002     "MAP_LENGTH": (1, False, command_maplength),
2003     "WORLD_ACTIVE": (1, False, command_worldactive),
2004     "MAP": (2, False, setter_map("MAP")),
2005     "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)),  # #
2006     "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")),  # #
2007     "PLANT_0": (1, False, specialtypesetter("PLANT_0")),  # #
2008     "PLANT_1": (1, False, specialtypesetter("PLANT_1")),  # #
2009     "LUMBER": (1, False, specialtypesetter("LUMBER")),  # #
2010     "TOOL_0": (1, False, specialtypesetter("TOOL_0")),  # #
2011     "EMPATHY": (1, False, setter(None, "EMPATHY", 0, 1)),  # #
2012     "TA_ID": (1, False, command_taid),
2013     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
2014     "TA_NAME": (1, False, command_taname),
2015     "TT_ID": (1, False, command_ttid),
2016     "TT_NAME": (1, False, command_ttname),
2017     "TT_TOOL": (1, False, command_tttool),
2018     "TT_SYMBOL": (1, False, command_ttsymbol),
2019     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
2020     "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
2021     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
2022                                          0, 255)),
2023     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2024                                         0, 65535)),
2025     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2026     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
2027     "T_ID": (1, False, command_tid),
2028     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2029     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2030     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2031     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2032     "T_COMMAND": (1, False, command_tcommand),
2033     "T_TYPE": (1, False, command_ttype),
2034     "T_CARRIES": (1, False, command_tcarries),
2035     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2036     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2037     "T_MEMTHING": (3, False, command_tmemthing),
2038     "T_POSY": (1, False, setter_tpos("Y")),
2039     "T_POSX": (1, False, setter_tpos("X")),
2040     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
2041     "wait": (0, False, play_commander("wait")),
2042     "move": (1, False, play_commander("move")),
2043     "pick_up": (0, False, play_commander("pick_up")),
2044     "drop": (1, False, play_commander("drop", True)),
2045     "use": (1, False, play_commander("use", True)),
2046     "ai": (0, False, command_ai)
2047 }
2048 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2049
2050
2051 """World state database. With sane default values. (Randomness is in rand.)"""
2052 world_db = {
2053     "TURN": 0,
2054     "MAP_LENGTH": 64,
2055     "PLAYER_TYPE": 0,
2056     "WORLD_ACTIVE": 0,
2057     "GOD_MOOD": 0,  # #
2058     "GOD_FAVOR": 0,  # #
2059     "MAP": False,
2060     "FAVOR_STAGE": 0,  # #
2061     "SLIPPERS": 0,  # #
2062     "PLANT_0": 0,  # #
2063     "PLANT_1": 0,  # #
2064     "LUMBER": 0,  # #
2065     "TOOL_0": 0,  # #
2066     "EMPATHY": 1,  # #
2067     "ThingActions": {},
2068     "ThingTypes": {},
2069     "Things": {}
2070 }
2071
2072 # 7DRL-specific!
2073 """Special type settings."""
2074 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"]  # #
2075
2076 """Mapping of direction names to internal direction chars."""
2077 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2078                  "west": "s", "north-west": "w", "north-east": "e"}
2079
2080 """File IO database."""
2081 io_db = {
2082     "path_save": "save",
2083     "path_record": "record_save",
2084     "path_worldconf": "confserver/world",
2085     "path_server": "server/",
2086     "path_in": "server/in",
2087     "path_out": "server/out",
2088     "path_worldstate": "server/worldstate",
2089     "tmp_suffix": "_tmp",
2090     "kicked_by_rival": False,
2091     "worldstate_updateable": False
2092 }
2093
2094
2095 try:
2096     libpr = prep_library()
2097     rand = RandomnessIO()
2098     opts = parse_command_line_arguments()
2099     if opts.savefile:
2100         io_db["path_save"] = opts.savefile
2101         io_db["path_record"] = "record_" + opts.savefile
2102     setup_server_io()
2103     if opts.verbose:
2104         io_db["verbose"] = True
2105     if None != opts.replay:
2106         replay_game()
2107     else:
2108         play_game()
2109 except SystemExit as exit:
2110     print("ABORTING: " + exit.args[0])
2111 except:
2112     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
2113     raise
2114 finally:
2115     cleanup_server_io()