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