home · contact · privacy
b5468a59c3b91fa675144f63fd9f1cb374df8e8d
[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     # 7DRL: Only player picks up non-food.
907     used_slots = len(t["T_CARRIES"]) # #
908     if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
909         ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
910                if not world_db["Things"][id]["carried"]
911                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
912                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
913         if len(ids):
914             lowest_tid = -1
915             for iid in ids:
916                 tid = world_db["Things"][iid]["T_TYPE"] 
917                 if lowest_tid == -1 or tid < lowest_tid:
918                     if (t != world_db["Things"][0] and  # #
919                         world_db["ThingTypes"][tid]["TT_TOOL"] != "food"):
920                         continue
921                     id = iid
922                     lowest_tid = tid
923             world_db["Things"][id]["carried"] = True
924             type = world_db["Things"][id]["T_TYPE"]  # #
925             if (t != world_db["Things"][0] # #
926                 and world_db["Things"][id]["T_PLAYERDROP"]  # #
927                 and world_db["ThingTypes"][type]["TT_TOOL"] == "food"):  # #
928                 score = world_db["ThingTypes"][type]["TT_TOOLPOWER"] / 32  # #
929                 add_gods_favor(score)  # #
930                 world_db["Things"][id]["T_PLAYERDROP"] = 0  # #
931             t["T_CARRIES"].append(id)
932             if t == world_db["Things"][0]:
933                 strong_write(io_db["file_out"], "LOG You pick up an object.\n")
934         elif t == world_db["Things"][0]:
935             err = "You try to pick up an object, but there is none."
936             strong_write(io_db["file_out"], "LOG " + err + "\n")
937     elif t == world_db["Things"][0]: # #
938         strong_write(io_db["file_out"], "LOG Can't pick up object: " + # #
939                                         "No storage room to carry more.\n") # #
940
941
942 def actor_drop(t):
943     """Make t rop Thing from inventory to ground indexed by T_ARGUMENT."""
944     # TODO: Handle case where T_ARGUMENT matches nothing.
945     if len(t["T_CARRIES"]):
946         id = t["T_CARRIES"][t["T_ARGUMENT"]]
947         t["T_CARRIES"].remove(id)
948         world_db["Things"][id]["carried"] = False
949         if t == world_db["Things"][0]:
950             strong_write(io_db["file_out"], "LOG You drop an object.\n")
951             world_db["Things"][id]["T_PLAYERDROP"] = 1  # #
952     elif t == world_db["Things"][0]:
953         err = "You try to drop an object, but you own none."
954         strong_write(io_db["file_out"], "LOG " + err + "\n")
955
956
957 def actor_use(t):
958     """Make t use (for now: consume) T_ARGUMENT-indexed Thing in inventory."""
959     # TODO: Handle case where T_ARGUMENT matches nothing.
960     # 7DLR: Handle SLIPPERS-type Thing use.
961     if len(t["T_CARRIES"]):
962         id = t["T_CARRIES"][t["T_ARGUMENT"]]
963         type = world_db["Things"][id]["T_TYPE"]
964         if type == world_db["SLIPPERS"]:  # #
965             if t == world_db["Things"][0]:  # #
966                 strong_write(io_db["file_out"], "LOG You use the "  # #
967                              + world_db["ThingTypes"][type]["TT_NAME"]  # #
968                              + ". It glows in wondrous colors, and emits "  # #
969                              + "a sound as if from a dying cat. The "  # #
970                              + "Island God laughs.\n")  # #
971             t["T_LIFEPOINTS"] = 1  # #
972             decrement_lifepoints(t)  # #
973         elif (world_db["ThingTypes"][type]["TT_TOOL"] == "axe"  # #
974               and t == world_db["Things"][0]):  # #
975                 strong_write(io_db["file_out"],  # #
976                              "LOG To use this item for chopping, move "  # #
977                              "towards a tree while carrying it in "  # #
978                              "your inventory.\n")  # #
979         elif (world_db["ThingTypes"][type]["TT_TOOL"] == "carpentry"):  # #
980             pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
981             if (world_db["MAP"][pos] == ord("X")  # #
982                 or world_db["MAP"][pos] == ord("|")):  # #
983                 strong_write(io_db["file_out"],  # #
984                              "LOG Can't build when standing on barrier.\n")  # #
985                 return
986             for id in [id for id in world_db["Things"]
987                        if not world_db["Things"][id] == t
988                        if not world_db["Things"][id]["carried"]
989                        if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
990                        if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]:
991                  strong_write(io_db["file_out"],
992                               "LOG Can't build when standing objects.\n")  # #
993                  return
994             for id in t["T_CARRIES"]:  # #
995                 type_tool = world_db["Things"][id]["T_TYPE"]  # #
996                 if (world_db["ThingTypes"][type_tool]["TT_TOOL"]  # #
997                     == "carpentry"):  # #
998                     break  # #
999             wood_id = None  # #
1000             for id in t["T_CARRIES"]:  # #
1001                 type_material = world_db["Things"][id]["T_TYPE"]  # #
1002                 if (world_db["ThingTypes"][type_material]["TT_TOOL"]  # #
1003                     == "wood"):  # #
1004                     wood_id = id  # #
1005                     break  # #
1006             if wood_id != None:  # #
1007                 t["T_CARRIES"].remove(wood_id)  # #
1008                 del world_db["Things"][wood_id]  # #
1009                 world_db["MAP"][pos] = ord("|")  # #
1010                 strong_write(io_db["file_out"], "LOG With your "  # #
1011                              + world_db["ThingTypes"][type_tool]["TT_NAME"]  # #
1012                              + " you build a wooden barrier from your "  # #
1013                              + world_db["ThingTypes"][type_material]  # #
1014                                ["TT_NAME"]  # #
1015                              + ".\n")  # #
1016             else:  # #
1017                 strong_write(io_db["file_out"], "LOG You can't use a "  # #
1018                              + world_db["ThingTypes"][type_tool]["TT_NAME"]  # #
1019                              + " without some wood in your inventory.\n")  # #
1020         elif world_db["ThingTypes"][type]["TT_TOOL"] == "food":
1021             t["T_CARRIES"].remove(id)
1022             del world_db["Things"][id]
1023             t["T_SATIATION"] += world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1024             if t == world_db["Things"][0]:
1025                 strong_write(io_db["file_out"],
1026                              "LOG You consume this object.\n")
1027         elif t == world_db["Things"][0]:
1028             strong_write(io_db["file_out"],
1029                          "LOG You try to use this object, but fail.\n")
1030     elif t == world_db["Things"][0]:
1031         strong_write(io_db["file_out"],
1032                      "LOG You try to use an object, but you own none.\n")
1033
1034
1035 def thingproliferation(t, prol_map):
1036     """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
1037
1038     Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
1039     marked "." in prol_map. If there are several map cell candidates, one is
1040     selected randomly.
1041     """
1042     # 7DRL: success increments God's mood
1043     # 7DRL: Plants (no TT_LIFEPOINTS) proliferate only on ":" ground.
1044     prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
1045     if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
1046         candidates = []
1047         for dir in [directions_db[key] for key in directions_db]:
1048             mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
1049             pos = mv_result[1] * world_db["MAP_LENGTH"] + mv_result[2]
1050             if mv_result[0] and \
1051                (ord(":") == prol_map[pos]  # #
1052                 or (world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
1053                     and ord(".") == prol_map[pos])):
1054             # if mv_result[0] and ord(".") == prol_map[mv_result[1]
1055             #                                          * world_db["MAP_LENGTH"]
1056             #                                          + mv_result[2]]:
1057                 candidates.append((mv_result[1], mv_result[2]))
1058         if len(candidates):
1059             i = rand.next() % len(candidates)
1060             id = id_setter(-1, "Things")
1061             newT = new_Thing(t["T_TYPE"], (candidates[i][0], candidates[i][1]))
1062             world_db["Things"][id] = newT
1063             animacy = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]  # #
1064             if animacy:  # #
1065                 world_db["GOD_MOOD"] += animacy  # #
1066             else:  # #
1067                 world_db["GOD_MOOD"] += 1  # #
1068             if (world_db["FAVOR_STAGE"] > 0  # #
1069                 and t["T_TYPE"] == world_db["PLANT_0"]):  # #
1070                 world_db["GOD_FAVOR"] += 5  # #
1071             elif t["T_TYPE"] == world_db["PLANT_1"]:  # #
1072                 world_db["GOD_FAVOR"] += 25  # #
1073
1074
1075 def try_healing(t):
1076     """If t's HP < max, increment them if well-nourished, maybe waiting."""
1077     # 7DRL: Successful heals increment God's mood.
1078     if t["T_LIFEPOINTS"] < \
1079        world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]:
1080         wait_id = [id for id in world_db["ThingActions"]
1081                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1082         wait_divider = 8 if t["T_COMMAND"] == wait_id else 1
1083         testval = int(abs(t["T_SATIATION"]) / wait_divider)
1084         if (testval <= 1 or 1 == (rand.next() % testval)):
1085             t["T_LIFEPOINTS"] += 1
1086             if t != world_db["Things"][0]: # #
1087                  world_db["GOD_MOOD"] += 1  # #
1088             if t == world_db["Things"][0]:
1089                 strong_write(io_db["file_out"], "LOG You heal.\n")
1090
1091
1092 def hunger(t):
1093     """Decrement t's satiation,dependent on it trigger lifepoint dec chance."""
1094     if t["T_SATIATION"] > -32768:
1095         max_hp = world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"]
1096         t["T_SATIATION"] -= int(math.sqrt(max_hp))
1097     if 0 != t["T_SATIATION"] and 0 == int(rand.next() / abs(t["T_SATIATION"])):
1098         if t == world_db["Things"][0]:
1099             if t["T_SATIATION"] < 0:
1100                 strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
1101             else:
1102                 strong_write(io_db["file_out"],
1103                              "LOG You suffer from over-eating.\n")
1104         decrement_lifepoints(t)
1105
1106
1107 def get_dir_to_target(t, filter):
1108     """Try to set T_COMMAND/T_ARGUMENT for move to "filter"-determined target.
1109
1110     The path-wise nearest target is chosen, via the shortest available path.
1111     Target must not be t. On succcess, return positive value, else False.
1112     Filters:
1113     "a": Thing in FOV is below a certain distance, animate, but of ThingType
1114          that is not t's, and starts out weaker than t is; build path as
1115          avoiding things of t's ThingType
1116     "f": neighbor cell (not inhabited by any animate Thing) further away from
1117          animate Thing not further than x steps away and in FOV and of a
1118          ThingType that is not t's, and starts out stronger or as strong as t
1119          is currently; or (cornered), if no such flight cell, but Thing of
1120          above criteria is too near,1 a cell closer to it, or, if less near,
1121          just wait
1122     "c": Thing in memorized map is consumable
1123     "s": memory map cell with greatest-reachable degree of unexploredness
1124     """
1125
1126     def zero_score_map_where_char_on_memdepthmap(c):
1127         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1128         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1129         #           if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
1130         #     set_map_score(i, 0)
1131         map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
1132         if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
1133             raise RuntimeError("No score map allocated for "
1134                                "zero_score_map_where_char_on_memdepthmap().")
1135
1136     def set_map_score(pos, score):
1137         test = libpr.set_map_score(pos, score)
1138         if test:
1139             raise RuntimeError("No score map allocated for set_map_score().")
1140
1141     def get_map_score(pos):
1142         result = libpr.get_map_score(pos)
1143         if result < 0:
1144             raise RuntimeError("No score map allocated for get_map_score().")
1145         return result
1146
1147     def seeing_thing():
1148         if t["fovmap"] and ("a" == filter or "f" == filter):
1149             for id in world_db["Things"]:
1150                 Thing = world_db["Things"][id]
1151                 if Thing != t and Thing["T_LIFEPOINTS"] and \
1152                    t["T_TYPE"] != Thing["T_TYPE"] and \
1153                    'v' == chr(t["fovmap"][(Thing["T_POSY"]
1154                                           * world_db["MAP_LENGTH"])
1155                                           + Thing["T_POSX"]]):
1156                     ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
1157                     if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
1158                                           t["T_LIFEPOINTS"]) \
1159                        or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
1160                                              t["T_LIFEPOINTS"]):
1161                         return True
1162         elif t["T_MEMMAP"] and "c" == filter:
1163             for mt in t["T_MEMTHING"]:
1164                 if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
1165                                          + mt[2]]) \
1166                    and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
1167                     return True
1168         return False
1169
1170     def set_cells_passable_on_memmap_to_65534_on_scoremap():
1171         # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
1172         # ord_dot = ord(".")
1173         # memmap = t["T_MEMMAP"]
1174         # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
1175         #            if ord_dot == memmap[i]]:
1176         #     set_map_score(i, 65534) # i.e. 65535-1
1177         map = c_pointer_to_bytearray(t["T_MEMMAP"])
1178         if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
1179             raise RuntimeError("No score map allocated for "
1180                         "set_cells_passable_on_memmap_to_65534_on_scoremap().")
1181
1182     def init_score_map():
1183         test = libpr.init_score_map()
1184         if test:
1185             raise RuntimeError("Malloc error in init_score_map().")
1186         ord_v = ord("v")
1187         ord_blank = ord(" ")
1188         set_cells_passable_on_memmap_to_65534_on_scoremap()
1189         if "a" == filter:
1190             for id in world_db["Things"]:
1191                 Thing = world_db["Things"][id]
1192                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1193                       + Thing["T_POSX"]
1194                 if t != Thing and Thing["T_LIFEPOINTS"] and \
1195                    t["T_TYPE"] != Thing["T_TYPE"] and \
1196                    ord_v == t["fovmap"][pos] and \
1197                    t["T_LIFEPOINTS"] > \
1198                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1199                     set_map_score(pos, 0)
1200                 elif t["T_TYPE"] == Thing["T_TYPE"]:
1201                     set_map_score(pos, 65535)
1202         elif "f" == filter:
1203             for id in [id for id in world_db["Things"]
1204                        if world_db["Things"][id]["T_LIFEPOINTS"]]:
1205                 Thing = world_db["Things"][id]
1206                 pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
1207                       + Thing["T_POSX"]
1208                 if t["T_TYPE"] != Thing["T_TYPE"] and \
1209                    ord_v == t["fovmap"][pos] and \
1210                    t["T_LIFEPOINTS"] <= \
1211                    world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
1212                     set_map_score(pos, 0)
1213         elif "c" == filter:
1214             for mt in [mt for mt in t["T_MEMTHING"]
1215                        if ord_blank != t["T_MEMMAP"][mt[1]
1216                                                     * world_db["MAP_LENGTH"]
1217                                                     + mt[2]]
1218                        if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
1219                 set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
1220         elif "s" == filter:
1221             zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
1222
1223     def rand_target_dir(neighbors, cmp, dirs):
1224         candidates = []
1225         n_candidates = 0
1226         for i in range(len(dirs)):
1227             if cmp == neighbors[i]:
1228                 candidates.append(dirs[i])
1229                 n_candidates += 1
1230         return candidates[rand.next() % n_candidates] if n_candidates else 0
1231
1232     def get_neighbor_scores(dirs, eye_pos):
1233         scores = []
1234         if libpr.ready_neighbor_scores(eye_pos):
1235             raise RuntimeError("No score map allocated for " +
1236                                "ready_neighbor_scores.()")
1237         for i in range(len(dirs)):
1238             scores.append(libpr.get_neighbor_score(i))
1239         return scores
1240
1241     def get_dir_from_neighbors():
1242         dir_to_target = False
1243         dirs = "edcxsw"
1244         eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
1245         neighbors = get_neighbor_scores(dirs, eye_pos)
1246         if "f" == filter:
1247             inhabited = [world_db["Things"][id]["T_POSY"]
1248                          * world_db["MAP_LENGTH"]
1249                          + world_db["Things"][id]["T_POSX"]
1250                          for id in world_db["Things"]
1251                          if world_db["Things"][id]["T_LIFEPOINTS"]]
1252             for i in range(len(dirs)):
1253                 mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
1254                 pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
1255                           + libpr.result_x()
1256                 for pos in [pos for pos in inhabited if pos == pos_cmp]:
1257                     neighbors[i] = 65535
1258                     break
1259         minmax_start = 0 if "f" == filter else 65535 - 1
1260         minmax_neighbor = minmax_start
1261         for i in range(len(dirs)):
1262             if ("f" == filter and get_map_score(eye_pos) < neighbors[i] and
1263                 minmax_neighbor < neighbors[i] and 65535 != neighbors[i]) \
1264                or ("f" != filter and minmax_neighbor > neighbors[i]):
1265                 minmax_neighbor = neighbors[i]
1266         if minmax_neighbor != minmax_start:
1267             dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
1268         if "f" == filter:
1269             if not dir_to_target:
1270                 if 1 == get_map_score(eye_pos):
1271                     dir_to_target = rand_target_dir(neighbors, 0, dirs)
1272                 elif 3 >= get_map_score(eye_pos):
1273                     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1274                                       if
1275                                       world_db["ThingActions"][id]["TA_NAME"]
1276                                          == "wait"][0]
1277                     return 1
1278             elif dir_to_target and 3 < get_map_score(eye_pos):
1279                 dir_to_target = 0
1280         elif "a" == filter and 10 <= get_map_score(eye_pos):
1281             dir_to_target = 0
1282         return dir_to_target
1283
1284     dir_to_target = False
1285     mem_depth_c = b' '
1286     run_i = 9 + 1 if "s" == filter else 1
1287     while run_i and not dir_to_target and ("s" == filter or seeing_thing()):
1288         run_i -= 1
1289         init_score_map()
1290         mem_depth_c = b'9' if b' ' == mem_depth_c \
1291                            else bytes([mem_depth_c[0] - 1])
1292         if libpr.dijkstra_map():
1293             raise RuntimeError("No score map allocated for dijkstra_map().")
1294         dir_to_target = get_dir_from_neighbors()
1295         libpr.free_score_map()
1296         if dir_to_target and str == type(dir_to_target):
1297             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1298                               if world_db["ThingActions"][id]["TA_NAME"]
1299                                  == "move"][0]
1300             t["T_ARGUMENT"] = ord(dir_to_target)
1301     return dir_to_target
1302
1303
1304 def standing_on_food(t):
1305     """Return True/False whether t is standing on a consumable."""
1306     for id in [id for id in world_db["Things"] if world_db["Things"][id] != t
1307                if not world_db["Things"][id]["carried"]
1308                if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
1309                if world_db["Things"][id]["T_POSX"] == t["T_POSX"]
1310                if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
1311                   ["TT_TOOL"] == "food"]:
1312         return True
1313     return False
1314
1315
1316 def get_inventory_slot_to_consume(t):
1317     """Return slot Id of healthiest consumable in t's inventory, else -1."""
1318     cmp_food = -1
1319     selection = -1
1320     i = 0
1321     for id in t["T_CARRIES"]:
1322         type = world_db["Things"][id]["T_TYPE"]
1323         if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
1324            and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
1325             nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
1326             tmp_cmp = abs(t["T_SATIATION"] + nutvalue)
1327             if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
1328             or tmp_cmp < cmp_food:
1329                 cmp_food = tmp_cmp
1330                 selection = i
1331         i += 1
1332     return selection
1333
1334
1335 def ai(t):
1336     """Determine next command/argment for actor t via AI algorithms.
1337
1338     AI will look for, and move towards, enemies (animate Things not of their
1339     own ThingType); if they see none, they will consume consumables in their
1340     inventory; if there are none, they will pick up what they stand on if they
1341     stand on consumables; if they stand on none, they will move towards the
1342     next consumable they see or remember on the map; if they see or remember
1343     none, they will explore parts of the map unseen since ever or for at least
1344     one turn; if there is nothing to explore, they will simply wait.
1345     """
1346     # 7DRL add: Don't pick up or search things when inventory is full.
1347     t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1348                       if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
1349     if not get_dir_to_target(t, "f"):
1350         sel = get_inventory_slot_to_consume(t)
1351         if -1 != sel:
1352             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1353                               if world_db["ThingActions"][id]["TA_NAME"]
1354                                  == "use"][0]
1355             t["T_ARGUMENT"] = sel
1356         elif standing_on_food(t) \
1357              and (len(t["T_CARRIES"]) < # #
1358                  world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
1359             t["T_COMMAND"] = [id for id in world_db["ThingActions"]
1360                               if world_db["ThingActions"][id]["TA_NAME"]
1361                                  == "pick_up"][0]
1362         elif (not
1363               (len(t["T_CARRIES"]) < # #
1364                 world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
1365                and get_dir_to_target(t, "c"))) and \
1366              (not get_dir_to_target(t, "a")):
1367             get_dir_to_target(t, "s")
1368
1369
1370 def turn_over():
1371     """Run game world and its inhabitants until new player input expected."""
1372     id = 0
1373     whilebreaker = False
1374     while world_db["Things"][0]["T_LIFEPOINTS"]:
1375         proliferable_map = world_db["MAP"][:]
1376         for id in [id for id in world_db["Things"]
1377                    if not world_db["Things"][id]["carried"]]:
1378             y = world_db["Things"][id]["T_POSY"]
1379             x = world_db["Things"][id]["T_POSX"]
1380             proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord("X")
1381         for id in [id for id in world_db["Things"]]:  # Only what's from start!
1382             if not id in world_db["Things"] or \
1383                world_db["Things"][id]["carried"]:   # May have been consumed or
1384                 continue                            # picked up during turn …
1385             Thing = world_db["Things"][id]
1386             if Thing["T_LIFEPOINTS"]:
1387                 if not Thing["T_COMMAND"]:
1388                     update_map_memory(Thing)
1389                     if 0 == id:
1390                         whilebreaker = True
1391                         break
1392                     ai(Thing)
1393                 try_healing(Thing)
1394                 hunger(Thing)
1395                 if Thing["T_LIFEPOINTS"]:
1396                     Thing["T_PROGRESS"] += 1
1397                     taid = [a for a in world_db["ThingActions"]
1398                               if a == Thing["T_COMMAND"]][0]
1399                     ThingAction = world_db["ThingActions"][taid]
1400                     if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
1401                         eval("actor_" + ThingAction["TA_NAME"])(Thing)
1402                         Thing["T_COMMAND"] = 0
1403                         Thing["T_PROGRESS"] = 0
1404             thingproliferation(Thing, proliferable_map)
1405         if whilebreaker:
1406             break
1407         world_db["TURN"] += 1
1408
1409
1410 def new_Thing(type, pos=(0, 0)):
1411     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
1412     thing = {
1413         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
1414         "T_ARGUMENT": 0,
1415         "T_PROGRESS": 0,
1416         "T_SATIATION": 0,
1417         "T_COMMAND": 0,
1418         "T_PLAYERDROP": 0,  # #
1419         "T_TYPE": type,
1420         "T_POSY": pos[0],
1421         "T_POSX": pos[1],
1422         "T_CARRIES": [],
1423         "carried": False,
1424         "T_MEMTHING": [],
1425         "T_MEMMAP": False,
1426         "T_MEMDEPTHMAP": False,
1427         "fovmap": False
1428     }
1429     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
1430         build_fov_map(thing)
1431     return thing
1432
1433
1434 def id_setter(id, category, id_store=False, start_at_1=False):
1435     """Set ID of object of category to manipulate ID unused? Create new one.
1436
1437     The ID is stored as id_store.id (if id_store is set). If the integer of the
1438     input is valid (if start_at_1, >= 0, else >= -1), but <0 or (if start_at_1)
1439     <1, calculate new ID: lowest unused ID >=0 or (if start_at_1) >= 1. None is
1440     always returned when no new object is created, otherwise the new object's
1441     ID.
1442     """
1443     min = 0 if start_at_1 else -1
1444     if str == type(id):
1445         id = integer_test(id, min)
1446     if None != id:
1447         if id in world_db[category]:
1448             if id_store:
1449                 id_store.id = id
1450             return None
1451         else:
1452             if (start_at_1 and 0 == id) \
1453                or ((not start_at_1) and (id < 0)):
1454                 id = 0 if start_at_1 else -1
1455                 while 1:
1456                     id = id + 1
1457                     if id not in world_db[category]:
1458                         break
1459             if id_store:
1460                 id_store.id = id
1461     return id
1462
1463
1464 def command_ping():
1465     """Send PONG line to server output file."""
1466     strong_write(io_db["file_out"], "PONG\n")
1467
1468
1469 def command_quit():
1470     """Abort server process."""
1471     if None == opts.replay:
1472         if world_db["WORLD_ACTIVE"]:
1473             save_world()
1474         atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
1475     raise SystemExit("received QUIT command")
1476
1477
1478 def command_thingshere(str_y, str_x):
1479     """Write to out file list of Things known to player at coordinate y, x."""
1480     # 7DRL: terrain, too
1481     if world_db["WORLD_ACTIVE"]:
1482         y = integer_test(str_y, 0, 255)
1483         x = integer_test(str_x, 0, 255)
1484         length = world_db["MAP_LENGTH"]
1485         if None != y and None != x and y < length and x < length:
1486             pos = (y * world_db["MAP_LENGTH"]) + x
1487             strong_write(io_db["file_out"], "THINGS_HERE START\n")
1488             pos = y * world_db["MAP_LENGTH"] + x;  # #
1489             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
1490                 for id in [id for tid in sorted(list(world_db["ThingTypes"]))
1491                               for id in world_db["Things"]
1492                               if not world_db["Things"][id]["carried"]
1493                               if world_db["Things"][id]["T_TYPE"] == tid
1494                               if y == world_db["Things"][id]["T_POSY"]
1495                               if x == world_db["Things"][id]["T_POSX"]]:
1496                     type = world_db["Things"][id]["T_TYPE"]
1497                     name = world_db["ThingTypes"][type]["TT_NAME"]
1498                     strong_write(io_db["file_out"], name + "\n")
1499             else:
1500                 for mt in [mt for tid in sorted(list(world_db["ThingTypes"]))
1501                               for mt in world_db["Things"][0]["T_MEMTHING"]
1502                               if mt[0] == tid if y == mt[1] if x == mt[2]]:
1503                     name = world_db["ThingTypes"][mt[0]]["TT_NAME"]
1504                     strong_write(io_db["file_out"], name + "\n")
1505             if world_db["Things"][0]["T_MEMMAP"][pos] == ord("~"):  # #
1506                 name = "(terrain: SEA)"  # #
1507             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("."):  # #
1508                 name = "(terrain: EARTH)"  # #
1509             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord(":"):  # #
1510                 name = "(terrain: SOIL)"  # #
1511             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("X"):  # #
1512                 name = "(terrain: TREE)"  # #
1513             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("|"):  # #
1514                 name = "(terrain: WALL)"  # #
1515             elif world_db["Things"][0]["T_MEMMAP"][pos] == ord("_"):  # #
1516                 name = "(terrain: ALTAR)"  # #
1517             else:  # #
1518                 name = "(?)"  # #
1519             strong_write(io_db["file_out"], name + "\n")  # #
1520             strong_write(io_db["file_out"], "THINGS_HERE END\n")
1521         else:
1522             print("Ignoring: Invalid map coordinates.")
1523     else:
1524         print("Ignoring: Command only works on existing worlds.")
1525
1526
1527 def play_commander(action, args=False):
1528     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
1529
1530     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
1531     """
1532
1533     def set_command():
1534         id = [x for x in world_db["ThingActions"]
1535                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
1536         world_db["Things"][0]["T_COMMAND"] = id
1537         turn_over()
1538
1539     def set_command_and_argument_int(str_arg):
1540         val = integer_test(str_arg, 0, 255)
1541         if None != val:
1542             world_db["Things"][0]["T_ARGUMENT"] = val
1543             set_command()
1544
1545     def set_command_and_argument_movestring(str_arg):
1546         if str_arg in directions_db:
1547             world_db["Things"][0]["T_ARGUMENT"] = ord(directions_db[str_arg])
1548             set_command()
1549         else:
1550             print("Ignoring: Argument must be valid direction string.")
1551
1552     if action == "move":
1553         return set_command_and_argument_movestring
1554     elif args:
1555         return set_command_and_argument_int
1556     else:
1557         return set_command
1558
1559
1560 def command_seedrandomness(seed_string):
1561     """Set rand seed to int(seed_string)."""
1562     val = integer_test(seed_string, 0, 4294967295)
1563     if None != val:
1564         rand.seed = val
1565
1566
1567 def command_makeworld(seed_string):
1568     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
1569
1570     Seed rand with seed. Do more only with a "wait" ThingAction and
1571     world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
1572     world_db["Things"] emptied, call make_map() and set
1573     world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
1574     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
1575     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
1576     other. Init player's memory map. Write "NEW_WORLD" line to out file.
1577     Call log_help().
1578     """
1579
1580     # def free_pos(plant=False):
1581     def free_pos(plant=False):  # #
1582         i = 0
1583         while 1:
1584             err = "Space to put thing on too hard to find. Map too small?"
1585             while 1:
1586                 y = rand.next() % world_db["MAP_LENGTH"]
1587                 x = rand.next() % world_db["MAP_LENGTH"]
1588                 pos = y * world_db["MAP_LENGTH"] + x;
1589                 if (not plant  # #
1590                     and "." == chr(world_db["MAP"][pos])) \
1591                    or ":" == chr(world_db["MAP"][pos]):  # #
1592                     break
1593                 i += 1
1594                 if i == 65535:
1595                     raise SystemExit(err)
1596             # Replica of C code, wrongly ignores animatedness of new Thing.
1597             pos_clear = (0 == len([id for id in world_db["Things"]
1598                                    if world_db["Things"][id]["T_LIFEPOINTS"]
1599                                    if world_db["Things"][id]["T_POSY"] == y
1600                                    if world_db["Things"][id]["T_POSX"] == x]))
1601             if pos_clear:
1602                 break
1603         return (y, x)
1604
1605     val = integer_test(seed_string, 0, 4294967295)
1606     if None == val:
1607         return
1608     rand.seed = val
1609     player_will_be_generated = False
1610     playertype = world_db["PLAYER_TYPE"]
1611     for ThingType in world_db["ThingTypes"]:
1612         if playertype == ThingType:
1613             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
1614                 player_will_be_generated = True
1615             break
1616     if not player_will_be_generated:
1617         print("Ignoring: No player type with start number >0 defined.")
1618         return
1619     wait_action = False
1620     for ThingAction in world_db["ThingActions"]:
1621         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1622             wait_action = True
1623     if not wait_action:
1624         print("Ignoring: No thing action with name 'wait' defined.")
1625         return
1626     for name in specials:  # #
1627         if world_db[name] not in world_db["ThingTypes"]:  # #
1628             print("Ignoring: No valid " + name + " set.")  # #
1629             return  # #
1630     world_db["Things"] = {}
1631     make_map()
1632     world_db["WORLD_ACTIVE"] = 1
1633     world_db["TURN"] = 1
1634     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
1635         id = id_setter(-1, "Things")
1636         world_db["Things"][id] = new_Thing(playertype, free_pos())
1637     if not world_db["Things"][0]["fovmap"]:
1638         empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1639         world_db["Things"][0]["fovmap"] = empty_fovmap
1640     update_map_memory(world_db["Things"][0])
1641     for type in world_db["ThingTypes"]:
1642         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
1643             if type != playertype:
1644                 id = id_setter(-1, "Things")
1645                 plantness = world_db["ThingTypes"][type]["TT_PROLIFERATE"]  # #
1646                 world_db["Things"][id] = new_Thing(type, free_pos(plantness))
1647     strong_write(io_db["file_out"], "NEW_WORLD\n")
1648     log_help()
1649
1650
1651 def command_maplength(maplength_string):
1652     """Redefine map length. Invalidate map, therefore lose all things on it."""
1653     val = integer_test(maplength_string, 1, 256)
1654     if None != val:
1655         world_db["MAP_LENGTH"] = val
1656         world_db["MAP"] = False
1657         set_world_inactive()
1658         world_db["Things"] = {}
1659         libpr.set_maplength(val)
1660
1661
1662 def command_worldactive(worldactive_string):
1663     """Toggle world_db["WORLD_ACTIVE"] if possible.
1664
1665     An active world can always be set inactive. An inactive world can only be
1666     set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
1667     map. On activation, rebuild all Things' FOVs, and the player's map memory.
1668     Also call log_help().
1669     """
1670     # 7DRL: altar must be on map, and specials must be set for active world.
1671     val = integer_test(worldactive_string, 0, 1)
1672     if None != val:
1673         if 0 != world_db["WORLD_ACTIVE"]:
1674             if 0 == val:
1675                 set_world_inactive()
1676             else:
1677                 print("World already active.")
1678         elif 0 == world_db["WORLD_ACTIVE"]:
1679             wait_exists = False
1680             for ThingAction in world_db["ThingActions"]:
1681                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
1682                     wait_exists = True
1683                     break
1684             player_exists = False
1685             for Thing in world_db["Things"]:
1686                 if 0 == Thing:
1687                     player_exists = True
1688                     break
1689             specials_set = True  # #
1690             for name in specials:  # #
1691                 if world_db[name] not in world_db["ThingTypes"]:  # #
1692                     specials_set = False  # #
1693             altar_found = False  # #
1694             if world_db["MAP"]:  # #
1695                 pos = world_db["MAP"].find(b'_')  # #
1696                 if pos > 0:  # #
1697                     y = int(pos / world_db["MAP_LENGTH"])  # #
1698                     x = pos % world_db["MAP_LENGTH"]  # #
1699                     world_db["altar"] = (y, x)  # #
1700                     altar_found = True  # #
1701             if wait_exists and player_exists and world_db["MAP"] \
1702                and specials_set:  # #
1703                 for id in world_db["Things"]:
1704                     if world_db["Things"][id]["T_LIFEPOINTS"]:
1705                         build_fov_map(world_db["Things"][id])
1706                         if 0 == id:
1707                             update_map_memory(world_db["Things"][id], False)
1708                 if not world_db["Things"][0]["T_LIFEPOINTS"]:
1709                     empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
1710                     world_db["Things"][0]["fovmap"] = empty_fovmap
1711                 world_db["WORLD_ACTIVE"] = 1
1712                 log_help()
1713             else:
1714                 print("Ignoring: Not all conditions for world activation met.")
1715
1716
1717 def specialtypesetter(name):  # #
1718     """Setter world_db[name], deactivating world if set int no ThingType."""
1719     def helper(str_int):
1720         val = integer_test(str_int, 0)
1721         if None != val:
1722             world_db[name] = val
1723             if world_db["WORLD_ACTIVE"] \
1724                and world_db[name] not in world_db["ThingTypes"]:
1725                 world_db["WORLD_ACTIVE"] = 0
1726                 print(name + " fits no known ThingType, deactivating world.")
1727     return helper
1728
1729
1730 def test_for_id_maker(object, category):
1731     """Return decorator testing for object having "id" attribute."""
1732     def decorator(f):
1733         def helper(*args):
1734             if hasattr(object, "id"):
1735                 f(*args)
1736             else:
1737                 print("Ignoring: No " + category +
1738                       " defined to manipulate yet.")
1739         return helper
1740     return decorator
1741
1742
1743 def command_tid(id_string):
1744     """Set ID of Thing to manipulate. ID unused? Create new one.
1745
1746     Default new Thing's type to the first available ThingType, others: zero.
1747     """
1748     id = id_setter(id_string, "Things", command_tid)
1749     if None != id:
1750         if world_db["ThingTypes"] == {}:
1751             print("Ignoring: No ThingType to settle new Thing in.")
1752             return
1753         type = list(world_db["ThingTypes"].keys())[0]
1754         world_db["Things"][id] = new_Thing(type)
1755
1756
1757 test_Thing_id = test_for_id_maker(command_tid, "Thing")
1758
1759
1760 @test_Thing_id
1761 def command_tcommand(str_int):
1762     """Set T_COMMAND of selected Thing."""
1763     val = integer_test(str_int, 0)
1764     if None != val:
1765         if 0 == val or val in world_db["ThingActions"]:
1766             world_db["Things"][command_tid.id]["T_COMMAND"] = val
1767         else:
1768             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
1769
1770
1771 @test_Thing_id
1772 def command_ttype(str_int):
1773     """Set T_TYPE of selected Thing."""
1774     val = integer_test(str_int, 0)
1775     if None != val:
1776         if val in world_db["ThingTypes"]:
1777             world_db["Things"][command_tid.id]["T_TYPE"] = val
1778         else:
1779             print("Ignoring: ThingType ID belongs to no known ThingType.")
1780
1781
1782 @test_Thing_id
1783 def command_tcarries(str_int):
1784     """Append int(str_int) to T_CARRIES of selected Thing.
1785
1786     The ID int(str_int) must not be of the selected Thing, and must belong to a
1787     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
1788     """
1789     val = integer_test(str_int, 0)
1790     if None != val:
1791         if val == command_tid.id:
1792             print("Ignoring: Thing cannot carry itself.")
1793         elif val in world_db["Things"] \
1794              and not world_db["Things"][val]["carried"]:
1795             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
1796             world_db["Things"][val]["carried"] = True
1797         else:
1798             print("Ignoring: Thing not available for carrying.")
1799     # Note that the whole carrying structure is different from the C version:
1800     # Carried-ness is marked by a "carried" flag, not by Things containing
1801     # Things internally.
1802
1803
1804 @test_Thing_id
1805 def command_tmemthing(str_t, str_y, str_x):
1806     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
1807
1808     The type must fit to an existing ThingType, and the position into the map.
1809     """
1810     type = integer_test(str_t, 0)
1811     posy = integer_test(str_y, 0, 255)
1812     posx = integer_test(str_x, 0, 255)
1813     if None != type and None != posy and None != posx:
1814         if type not in world_db["ThingTypes"] \
1815            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
1816             print("Ignoring: Illegal value for thing type or position.")
1817         else:
1818             memthing = (type, posy, posx)
1819             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
1820
1821
1822 def setter_map(maptype):
1823     """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
1824
1825     If no map of maptype exists yet, initialize it with ' ' bytes first.
1826     """
1827
1828     def valid_map_line(str_int, mapline):
1829         val = integer_test(str_int, 0, 255)
1830         if None != val:
1831             if val >= world_db["MAP_LENGTH"]:
1832                 print("Illegal value for map line number.")
1833             elif len(mapline) != world_db["MAP_LENGTH"]:
1834                 print("Map line length is unequal map width.")
1835             else:
1836                 return val
1837         return None
1838
1839     def nonThingMap_helper(str_int, mapline):
1840         val = valid_map_line(str_int, mapline)
1841         if None != val:
1842             length = world_db["MAP_LENGTH"]
1843             if not world_db["MAP"]:
1844                 map = bytearray(b' ' * (length ** 2))
1845             else:
1846                 map = world_db["MAP"]
1847             map[val * length:(val * length) + length] = mapline.encode()
1848             if not world_db["MAP"]:
1849                 world_db["MAP"] = map
1850
1851     @test_Thing_id
1852     def ThingMap_helper(str_int, mapline):
1853         val = valid_map_line(str_int, mapline)
1854         if None != val:
1855             length = world_db["MAP_LENGTH"]
1856             if not world_db["Things"][command_tid.id][maptype]:
1857                 map = bytearray(b' ' * (length ** 2))
1858             else:
1859                 map = world_db["Things"][command_tid.id][maptype]
1860             map[val * length:(val * length) + length] = mapline.encode()
1861             if not world_db["Things"][command_tid.id][maptype]:
1862                 world_db["Things"][command_tid.id][maptype] = map
1863
1864     return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
1865
1866
1867 def setter_tpos(axis):
1868     """Generate setter for T_POSX or  T_POSY of selected Thing.
1869
1870     If world is active, rebuilds animate things' fovmap, player's memory map.
1871     """
1872     @test_Thing_id
1873     def helper(str_int):
1874         val = integer_test(str_int, 0, 255)
1875         if None != val:
1876             if val < world_db["MAP_LENGTH"]:
1877                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
1878                 if world_db["WORLD_ACTIVE"] \
1879                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
1880                     build_fov_map(world_db["Things"][command_tid.id])
1881                     if 0 == command_tid.id:
1882                         update_map_memory(world_db["Things"][command_tid.id])
1883             else:
1884                 print("Ignoring: Position is outside of map.")
1885     return helper
1886
1887
1888 def command_ttid(id_string):
1889     """Set ID of ThingType to manipulate. ID unused? Create new one.
1890
1891     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, TT_TOOL to
1892     "", others: 0.
1893     """
1894     id = id_setter(id_string, "ThingTypes", command_ttid)
1895     if None != id:
1896         world_db["ThingTypes"][id] = {
1897             "TT_NAME": "(none)",
1898             "TT_TOOLPOWER": 0,
1899             "TT_LIFEPOINTS": 0,
1900             "TT_PROLIFERATE": 0,
1901             "TT_START_NUMBER": 0,
1902             "TT_STORAGE": 0, # #
1903             "TT_SYMBOL": "?",
1904             "TT_CORPSE_ID": id,
1905             "TT_TOOL": ""
1906         }
1907
1908
1909 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
1910
1911
1912 @test_ThingType_id
1913 def command_ttname(name):
1914     """Set TT_NAME of selected ThingType."""
1915     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
1916
1917
1918 @test_ThingType_id
1919 def command_tttool(name):
1920     """Set TT_TOOL of selected ThingType."""
1921     world_db["ThingTypes"][command_ttid.id]["TT_TOOL"] = name
1922
1923
1924 @test_ThingType_id
1925 def command_ttsymbol(char):
1926     """Set TT_SYMBOL of selected ThingType. """
1927     if 1 == len(char):
1928         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
1929     else:
1930         print("Ignoring: Argument must be single character.")
1931
1932
1933 @test_ThingType_id
1934 def command_ttcorpseid(str_int):
1935     """Set TT_CORPSE_ID of selected ThingType."""
1936     val = integer_test(str_int, 0)
1937     if None != val:
1938         if val in world_db["ThingTypes"]:
1939             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
1940         else:
1941             print("Ignoring: Corpse ID belongs to no known ThignType.")
1942
1943
1944 def command_taid(id_string):
1945     """Set ID of ThingAction to manipulate. ID unused? Create new one.
1946
1947     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
1948     """
1949     id = id_setter(id_string, "ThingActions", command_taid, True)
1950     if None != id:
1951         world_db["ThingActions"][id] = {
1952             "TA_EFFORT": 1,
1953             "TA_NAME": "wait"
1954         }
1955
1956
1957 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
1958
1959
1960 @test_ThingAction_id
1961 def command_taname(name):
1962     """Set TA_NAME of selected ThingAction.
1963
1964     The name must match a valid thing action function. If after the name
1965     setting no ThingAction with name "wait" remains, call set_world_inactive().
1966     """
1967     if name == "wait" or name == "move" or name == "use" or name == "drop" \
1968        or name == "pick_up":
1969         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
1970         if 1 == world_db["WORLD_ACTIVE"]:
1971             wait_defined = False
1972             for id in world_db["ThingActions"]:
1973                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
1974                     wait_defined = True
1975                     break
1976             if not wait_defined:
1977                 set_world_inactive()
1978     else:
1979         print("Ignoring: Invalid action name.")
1980     # In contrast to the original,naming won't map a function to a ThingAction.
1981
1982
1983 def command_ai():
1984     """Call ai() on player Thing, then turn_over()."""
1985     ai(world_db["Things"][0])
1986     turn_over()
1987
1988
1989 """Commands database.
1990
1991 Map command start tokens to ([0]) number of expected command arguments, ([1])
1992 the command's meta-ness (i.e. is it to be written to the record file, is it to
1993 be ignored in replay mode if read from server input file), and ([2]) a function
1994 to be called on it.
1995 """
1996 commands_db = {
1997     "QUIT": (0, True, command_quit),
1998     "PING": (0, True, command_ping),
1999     "THINGS_HERE": (2, True, command_thingshere),
2000     "MAKE_WORLD": (1, False, command_makeworld),
2001     "SEED_RANDOMNESS": (1, False, command_seedrandomness),
2002     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
2003     "GOD_MOOD": (1, False, setter(None, "GOD_MOOD", -32768, 32767)),  # #
2004     "GOD_FAVOR": (1, False, setter(None, "GOD_FAVOR", -32768, 32767)),  # #
2005     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
2006     "MAP_LENGTH": (1, False, command_maplength),
2007     "WORLD_ACTIVE": (1, False, command_worldactive),
2008     "MAP": (2, False, setter_map("MAP")),
2009     "FAVOR_STAGE": (1, False, setter(None, "FAVOR_STAGE", 0, 65535)),  # #
2010     "SLIPPERS": (1, False, specialtypesetter("SLIPPERS")),  # #
2011     "PLANT_0": (1, False, specialtypesetter("PLANT_0")),  # #
2012     "PLANT_1": (1, False, specialtypesetter("PLANT_1")),  # #
2013     "LUMBER": (1, False, specialtypesetter("LUMBER")),  # #
2014     "TOOL_0": (1, False, specialtypesetter("TOOL_0")),  # #
2015     "EMPATHY": (1, False, setter(None, "EMPATHY", 0, 1)),  # #
2016     "TA_ID": (1, False, command_taid),
2017     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
2018     "TA_NAME": (1, False, command_taname),
2019     "TT_ID": (1, False, command_ttid),
2020     "TT_NAME": (1, False, command_ttname),
2021     "TT_TOOL": (1, False, command_tttool),
2022     "TT_SYMBOL": (1, False, command_ttsymbol),
2023     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
2024     "TT_TOOLPOWER": (1, False, setter("ThingType", "TT_TOOLPOWER", 0, 65535)),
2025     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
2026                                          0, 255)),
2027     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
2028                                         0, 65535)),
2029     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
2030     "TT_STORAGE": (1, False, setter("ThingType", "TT_STORAGE", 0, 255)),  # #
2031     "T_ID": (1, False, command_tid),
2032     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
2033     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
2034     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
2035     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
2036     "T_COMMAND": (1, False, command_tcommand),
2037     "T_TYPE": (1, False, command_ttype),
2038     "T_CARRIES": (1, False, command_tcarries),
2039     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
2040     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
2041     "T_MEMTHING": (3, False, command_tmemthing),
2042     "T_POSY": (1, False, setter_tpos("Y")),
2043     "T_POSX": (1, False, setter_tpos("X")),
2044     "T_PLAYERDROP": (1, False, setter("Thing", "T_PLAYERDROP", 0, 1)),  # #
2045     "wait": (0, False, play_commander("wait")),
2046     "move": (1, False, play_commander("move")),
2047     "pick_up": (0, False, play_commander("pick_up")),
2048     "drop": (1, False, play_commander("drop", True)),
2049     "use": (1, False, play_commander("use", True)),
2050     "ai": (0, False, command_ai)
2051 }
2052 # TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
2053
2054
2055 """World state database. With sane default values. (Randomness is in rand.)"""
2056 world_db = {
2057     "TURN": 0,
2058     "MAP_LENGTH": 64,
2059     "PLAYER_TYPE": 0,
2060     "WORLD_ACTIVE": 0,
2061     "GOD_MOOD": 0,  # #
2062     "GOD_FAVOR": 0,  # #
2063     "MAP": False,
2064     "FAVOR_STAGE": 0,  # #
2065     "SLIPPERS": 0,  # #
2066     "PLANT_0": 0,  # #
2067     "PLANT_1": 0,  # #
2068     "LUMBER": 0,  # #
2069     "TOOL_0": 0,  # #
2070     "EMPATHY": 1,  # #
2071     "ThingActions": {},
2072     "ThingTypes": {},
2073     "Things": {}
2074 }
2075
2076 # 7DRL-specific!
2077 """Special type settings."""
2078 specials = ["SLIPPERS", "PLANT_0", "PLANT_1", "LUMBER", "TOOL_0"]  # #
2079
2080 """Mapping of direction names to internal direction chars."""
2081 directions_db = {"east": "d", "south-east": "c", "south-west": "x",
2082                  "west": "s", "north-west": "w", "north-east": "e"}
2083
2084 """File IO database."""
2085 io_db = {
2086     "path_save": "save",
2087     "path_record": "record_save",
2088     "path_worldconf": "confserver/world",
2089     "path_server": "server/",
2090     "path_in": "server/in",
2091     "path_out": "server/out",
2092     "path_worldstate": "server/worldstate",
2093     "tmp_suffix": "_tmp",
2094     "kicked_by_rival": False,
2095     "worldstate_updateable": False
2096 }
2097
2098
2099 try:
2100     libpr = prep_library()
2101     rand = RandomnessIO()
2102     opts = parse_command_line_arguments()
2103     if opts.savefile:
2104         io_db["path_save"] = opts.savefile
2105         io_db["path_record"] = "record_" + opts.savefile
2106     setup_server_io()
2107     if opts.verbose:
2108         io_db["verbose"] = True
2109     if None != opts.replay:
2110         replay_game()
2111     else:
2112         play_game()
2113 except SystemExit as exit:
2114     print("ABORTING: " + exit.args[0])
2115 except:
2116     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
2117     raise
2118 finally:
2119     cleanup_server_io()