home · contact · privacy
fda9b29df5d5e42dfa9821f6f97b63ef885e4bcb
[plomrogue] / plomrogue-server.py
1 import argparse
2 import errno
3 import os
4 import shlex
5 import shutil
6 import time
7
8
9 def strong_write(file, string):
10     """Apply write(string), flush(), and os.fsync() to file."""
11     file.write(string)
12     file.flush()
13     os.fsync(file)
14
15
16 def setup_server_io():
17     """Fill IO files DB with proper file( path)s. Write process IO test string.
18
19     Ensure IO files directory at server/. Remove any old input file if found.
20     Set up new input file for reading, and new output file for writing. Start
21     output file with process hash line of format PID + " " + floated UNIX time
22     (io_db["teststring"]). Raise SystemExit if file is found at path of either
23     record or save file plus io_db["tmp_suffix"].
24     """
25     def detect_atomic_leftover(path, tmp_suffix):
26         path_tmp = path + tmp_suffix
27         msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
28               "aborted previous attempt to write '" + path + "'. Aborting " \
29              "until matter is resolved by removing it from its current path."
30         if os.access(path_tmp, os.F_OK):
31             raise SystemExit(msg)
32     io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
33     os.makedirs(io_db["path_server"], exist_ok=True)
34     io_db["file_out"] = open(io_db["path_out"], "w")
35     strong_write(io_db["file_out"], io_db["teststring"] + "\n")
36     if os.access(io_db["path_in"], os.F_OK):
37         os.remove(io_db["path_in"])
38     io_db["file_in"] = open(io_db["path_in"], "w")
39     io_db["file_in"].close()
40     io_db["file_in"] = open(io_db["path_in"], "r")
41     detect_atomic_leftover(io_db["path_save"], io_db["tmp_suffix"])
42     detect_atomic_leftover(io_db["path_record"], io_db["tmp_suffix"])
43
44
45 def cleanup_server_io():
46     """Close and (if io_db["kicked_by_rival"] false) remove files in io_db."""
47     def helper(file_key, path_key):
48         if file_key in io_db:
49             io_db[file_key].close()
50             if not io_db["kicked_by_rival"] \
51                and os.access(io_db[path_key], os.F_OK):
52                 os.remove(io_db[path_key])
53     helper("file_out", "path_out")
54     helper("file_in", "path_in")
55     helper("file_worldstate", "path_worldstate")
56     if "file_record" in io_db:
57         io_db["file_record"].close()
58
59
60 def obey(command, prefix, replay=False, do_record=False):
61     """Call function from commands_db mapped to command's first token.
62
63     Tokenize command string with shlex.split(comments=True). If replay is set,
64     a non-meta command from the commands_db merely triggers obey() on the next
65     command from the records file. If not, non-meta commands set
66     io_db["worldstate_updateable"] to world_db["WORLD_EXISTS"], and, if
67     do_record is set, are recorded via record(), and save_world() is called.
68     The prefix string is inserted into the server's input message between its
69     beginning 'input ' & ':'. All activity is preceded by a server_test() call.
70     """
71     server_test()
72     print("input " + prefix + ": " + command)
73     try:
74         tokens = shlex.split(command, comments=True)
75     except ValueError as err:
76         print("Can't tokenize command string: " + str(err) + ".")
77         return
78     if len(tokens) > 0 and tokens[0] in commands_db \
79        and len(tokens) == commands_db[tokens[0]][0] + 1:
80         if commands_db[tokens[0]][1]:
81             commands_db[tokens[0]][2](*tokens[1:])
82         elif replay:
83             print("Due to replay mode, reading command as 'go on in record'.")
84             line = io_db["file_record"].readline()
85             if len(line) > 0:
86                 obey(line.rstrip(), io_db["file_record"].prefix
87                      + str(io_db["file_record"].line_n))
88                 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
89             else:
90                 print("Reached end of record file.")
91         else:
92             commands_db[tokens[0]][2](*tokens[1:])
93             if do_record:
94                 record(command)
95                 save_world()
96             io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
97     elif 0 != len(tokens):
98         print("Invalid command/argument, or bad number of tokens.")
99
100
101 def atomic_write(path, text, do_append=False):
102     """Atomic write of text to file at path, appended if do_append is set."""
103     path_tmp = path + io_db["tmp_suffix"]
104     mode = "w"
105     if do_append:
106         mode = "a"
107         if os.access(path, os.F_OK):
108             shutil.copyfile(path, path_tmp)
109     file = open(path_tmp, mode)
110     strong_write(file, text)
111     file.close()
112     if os.access(path, os.F_OK):
113         os.remove(path)
114     os.rename(path_tmp, path)
115
116
117 def record(command):
118     """Append command string plus newline to record file. (Atomic.)"""
119     # This misses some optimizations from the original record(), namely only
120     # finishing the atomic write with expensive flush() and fsync() every 15
121     # seconds unless explicitely forced. Implement as needed.
122     atomic_write(io_db["path_record"], command + "\n", do_append=True)
123
124
125 def save_world():
126     """Save all commands needed to reconstruct current world state."""
127     # TODO: Misses same optimizations as record() from the original record().
128
129     def quote(string):
130         string = string.replace("\u005C", '\u005C\u005C')
131         return '"' + string.replace('"', '\u005C"') + '"'
132
133     def mapsetter(key):
134         def helper(id):
135             string = ""
136             if world_db["Things"][id][key]:
137                 map = world_db["Things"][id][key]
138                 length = world_db["MAP_LENGTH"]
139                 for i in range(length):
140                     line = map[i * length:(i * length) + length].decode()
141                     string = string + key + " " + str(i) + " " + quote(line) \
142                              + "\n"
143             return string
144         return helper
145
146     def memthing(id):
147         string = ""
148         for memthing in world_db["Things"][id]["T_MEMTHING"]:
149             string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
150                      str(memthing[1]) + " " + str(memthing[2]) + "\n"
151         return string
152
153     def helper(category, id_string, special_keys={}):
154         string = ""
155         for id in world_db[category]:
156             string = string + id_string + " " + str(id) + "\n"
157             for key in world_db[category][id]:
158                 if not key in special_keys:
159                     x = world_db[category][id][key]
160                     argument = quote(x) if str == type(x) else str(x)
161                     string = string + key + " " + argument + "\n"
162                 elif special_keys[key]:
163                     string = string + special_keys[key](id)
164         return string
165
166     string = ""
167     for key in world_db:
168         if dict != type(world_db[key]) and key != "MAP":
169             string = string + key + " " + str(world_db[key]) + "\n"
170     string = string + helper("ThingActions", "TA_ID")
171     string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
172     for id in world_db["ThingTypes"]:
173         string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
174                  str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
175     string = string + helper("Things", "T_ID",
176                              {"T_CARRIES": False, "carried": False,
177                               "T_MEMMAP": mapsetter("T_MEMMAP"),
178                               "T_MEMTHING": memthing, "fovmap": False,
179                               "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
180     for id in world_db["Things"]:
181         if [] != world_db["Things"][id]["T_CARRIES"]:
182             string = string + "T_ID " + str(id) + "\n"
183             for carried_id in world_db["Things"][id]["T_CARRIES"]:
184                 string = string + "T_CARRIES " + str(carried_id) + "\n"
185     string = string + "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
186     atomic_write(io_db["path_save"], string)
187
188
189 def obey_lines_in_file(path, name, do_record=False):
190     """Call obey() on each line of path's file, use name in input prefix."""
191     file = open(path, "r")
192     line_n = 1
193     for line in file.readlines():
194         obey(line.rstrip(), name + "file line " + str(line_n),
195              do_record=do_record)
196         line_n = line_n + 1
197     file.close()
198
199
200 def parse_command_line_arguments():
201     """Return settings values read from command line arguments."""
202     parser = argparse.ArgumentParser()
203     parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
204                         action='store')
205     opts, unknown = parser.parse_known_args()
206     return opts
207
208
209 def server_test():
210     """Ensure valid server out file belonging to current process.
211
212     This is done by comparing io_db["teststring"] to what's found at the start
213     of the current file at io_db["path_out"]. On failure, set
214     io_db["kicked_by_rival"] and raise SystemExit.
215     """
216     if not os.access(io_db["path_out"], os.F_OK):
217         raise SystemExit("Server output file has disappeared.")
218     file = open(io_db["path_out"], "r")
219     test = file.readline().rstrip("\n")
220     file.close()
221     if test != io_db["teststring"]:
222         io_db["kicked_by_rival"] = True
223         msg = "Server test string in server output file does not match. This" \
224               " indicates that the current server process has been " \
225               "superseded by another one."
226         raise SystemExit(msg)
227
228
229 def read_command():
230     """Return next newline-delimited command from server in file.
231
232     Keep building return string until a newline is encountered. Pause between
233     unsuccessful reads, and after too much waiting, run server_test().
234     """
235     wait_on_fail = 1
236     max_wait = 5
237     now = time.time()
238     command = ""
239     while True:
240         add = io_db["file_in"].readline()
241         if len(add) > 0:
242             command = command + add
243             if len(command) > 0 and "\n" == command[-1]:
244                 command = command[:-1]
245                 break
246         else:
247             time.sleep(wait_on_fail)
248             if now + max_wait < time.time():
249                 server_test()
250                 now = time.time()
251     return command
252
253
254 def try_worldstate_update():
255     """Write worldstate file if io_db["worldstate_updateable"] is set."""
256     if io_db["worldstate_updateable"]:
257
258         def draw_visible_Things(map, run):
259             for id in world_db["Things"]:
260                 type = world_db["Things"][id]["T_TYPE"]
261                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
262                 alive = world_db["ThingTypes"][type]["TT_LIFEPOINTS"]
263                 if (0 == run and not consumable and not alive) \
264                    or (1 == run and consumable and not alive) \
265                    or (2 == run and alive):
266                     y = world_db["Things"][id]["T_POSY"]
267                     x = world_db["Things"][id]["T_POSX"]
268                     fovflag = world_db["Things"][0]["fovmap"][(y * length) + x]
269                     if 'v' == chr(fovflag):
270                         c = world_db["ThingTypes"][type]["TT_SYMBOL"]
271                         map[(y * length) + x] = ord(c)
272
273         def write_map(string, map):
274             for i in range(length):
275                 line = map[i * length:(i * length) + length].decode()
276                 string = string + line + "\n"
277             return string
278
279         inventory = ""
280         if [] == world_db["Things"][0]["T_CARRIES"]:
281             inventory = "(none)\n"
282         else:
283             for id in world_db["Things"][0]["T_CARRIES"]:
284                 type_id = world_db["Things"][id]["T_TYPE"]
285                 name = world_db["ThingTypes"][type_id]["TT_NAME"]
286                 inventory = inventory + name + "\n"
287         string = str(world_db["TURN"]) + "\n" + \
288                  str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
289                  str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
290                  inventory + "%\n" + \
291                  str(world_db["Things"][0]["T_POSY"]) + "\n" + \
292                  str(world_db["Things"][0]["T_POSX"]) + "\n" + \
293                  str(world_db["MAP_LENGTH"]) + "\n"
294         length = world_db["MAP_LENGTH"]
295         fov = bytearray(b' ' * (length ** 2))
296         for pos in range(length ** 2):
297             if 'v' == chr(world_db["Things"][0]["fovmap"][pos]):
298                 fov[pos] = world_db["MAP"][pos]
299         for i in range(3):
300             draw_visible_Things(fov, i)
301         string = write_map(string, fov)
302         mem = world_db["Things"][0]["T_MEMMAP"][:]
303         for i in range(2):
304             for memthing in world_db["Things"][0]["T_MEMTHING"]:
305                 type = world_db["Things"][memthing[0]]["T_TYPE"]
306                 consumable = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
307                 if (i == 0 and not consumable) or (i == 1 and consumable):
308                     c = world_db["ThingTypes"][type]["TT_SYMBOL"]
309                     mem[(memthing[1] * length) + memthing[2]] = ord(c)
310         string = write_map(string, mem)
311         atomic_write(io_db["path_worldstate"], string)
312         strong_write(io_db["file_out"], "WORLD_UPDATED\n")
313         io_db["worldstate_updateable"] = False
314
315
316 def replay_game():
317     """Replay game from record file.
318
319     Use opts.replay as breakpoint turn to which to replay automatically before
320     switching to manual input by non-meta commands in server input file
321     triggering further reads of record file. Ensure opts.replay is at least 1.
322     Run try_worldstate_update() before each interactive obey()/read_command().
323     """
324     if opts.replay < 1:
325         opts.replay = 1
326     print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
327           " (if so late a turn is to be found).")
328     if not os.access(io_db["path_record"], os.F_OK):
329         raise SystemExit("No record file found to replay.")
330     io_db["file_record"] = open(io_db["path_record"], "r")
331     io_db["file_record"].prefix = "record file line "
332     io_db["file_record"].line_n = 1
333     while world_db["TURN"] < opts.replay:
334         line = io_db["file_record"].readline()
335         if "" == line:
336             break
337         obey(line.rstrip(), io_db["file_record"].prefix
338              + str(io_db["file_record"].line_n))
339         io_db["file_record"].line_n = io_db["file_record"].line_n + 1
340     while True:
341         try_worldstate_update()
342         obey(read_command(), "in file", replay=True)
343
344
345 def play_game():
346     """Play game by server input file commands. Before, load save file found.
347
348     If no save file is found, a new world is generated from the commands in the
349     world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
350     command and all that follow via the server input file. Run
351     try_worldstate_update() before each interactive obey()/read_command().
352     """
353     if os.access(io_db["path_save"], os.F_OK):
354         obey_lines_in_file(io_db["path_save"], "save")
355     else:
356         if not os.access(io_db["path_worldconf"], os.F_OK):
357             msg = "No world config file from which to start a new world."
358             raise SystemExit(msg)
359         obey_lines_in_file(io_db["path_worldconf"], "world config ",
360                            do_record=True)
361         obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
362     while True:
363         try_worldstate_update()
364         obey(read_command(), "in file", do_record=True)
365
366
367 def remake_map():
368     # DUMMY map creator.
369     world_db["MAP"] = bytearray(b'.' * (world_db["MAP_LENGTH"] ** 2))
370
371
372 def update_map_memory(t):
373     """Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
374     if not t["T_MEMMAP"]:
375         t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
376     if not t["T_MEMDEPTHMAP"]:
377         t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
378     for pos in range(world_db["MAP_LENGTH"] ** 2):
379         if "v" == chr(t["fovmap"][pos]):
380             t["T_MEMDEPTHMAP"][pos] = ord("0")
381             if " " == chr(t["T_MEMMAP"][pos]):
382                 t["T_MEMMAP"][pos] = world_db["MAP"][pos]
383             continue
384         # TODO: Aging of MEMDEPTHMAP.
385     for memthing in t["T_MEMTHING"]:
386         y = world_db["Things"][memthing[0]]["T_POSY"]
387         x = world_db["Things"][memthing[1]]["T_POSY"]
388         if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
389             t["T_MEMTHING"].remove(memthing)
390     for id in world_db["Things"]:
391         type = world_db["Things"][id]["T_TYPE"]
392         if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
393             y = world_db["Things"][id]["T_POSY"]
394             x = world_db["Things"][id]["T_POSY"]
395             if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
396                 t["T_MEMTHING"].append((type, y, x))
397
398
399 def set_world_inactive():
400     """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
401     server_test()
402     if os.access(io_db["path_worldstate"], os.F_OK):
403         os.remove(io_db["path_worldstate"])
404     world_db["WORLD_ACTIVE"] = 0
405
406
407 def integer_test(val_string, min, max):
408     """Return val_string if possible integer >= min and <= max, else None."""
409     try:
410         val = int(val_string)
411         if val < min or val > max:
412             raise ValueError
413         return val
414     except ValueError:
415         print("Ignoring: Please use integer >= " + str(min) + " and <= " +
416               str(max) + ".")
417         return None
418
419
420 def setter(category, key, min, max):
421     """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
422     if category is None:
423         def f(val_string):
424             val = integer_test(val_string, min, max)
425             if None != val:
426                 world_db[key] = val
427     else:
428         if category == "Thing":
429             id_store = command_tid
430             decorator = test_Thing_id
431         elif category == "ThingType":
432             id_store = command_ttid
433             decorator = test_ThingType_id
434         elif category == "ThingAction":
435             id_store = command_taid
436             decorator = test_ThingAction_id
437
438         @decorator
439         def f(val_string):
440             val = integer_test(val_string, min, max)
441             if None != val:
442                 world_db[category + "s"][id_store.id][key] = val
443     return f
444
445
446 def build_fov_map(t):
447     """Build Thing's FOV map."""
448     t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
449     # DUMMY so far. Just builds an all-visible map.
450
451
452 def turn_over():
453     """Run game world and its inhabitants until new player input expected."""
454     id = 0
455     whilebreaker = False
456     while world_db["Things"][0]["T_LIFEPOINTS"]:
457         for id in [id for id in world_db["Things"]
458                       if not world_db["Things"][id]["carried"]
459                       if world_db["Things"][id]["T_LIFEPOINTS"]]:
460             Thing = world_db["Things"][id]
461             if Thing["T_LIFEPOINTS"]:
462                 if not Thing["T_COMMAND"]:
463                     update_map_memory(Thing)
464                     if 0 == id:
465                         whilebreaker = True
466                         break
467                     # DUMMY: ai(thing)
468                     Thing["T_COMMAND"] = 1
469                 # DUMMY: try_healing
470                 Thing["T_PROGRESS"] += 1
471                 taid = [a for a in world_db["ThingActions"]
472                           if a == Thing["T_COMMAND"]][0]
473                 ThingAction = world_db["ThingActions"][taid]
474                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
475                     # run_thing_action(action["TA_NAME"])
476                     Thing["T_COMMAND"] = 0
477                     Thing["T_PROGRESS"] = 0
478                 # DUMMY: hunger
479             # DUMMY: thingproliferation
480         if whilebreaker:
481             break
482         world_db["TURN"] += 1
483
484
485 def new_Thing(type):
486     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
487     thing = {
488         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
489         "T_ARGUMENT": 0,
490         "T_PROGRESS": 0,
491         "T_SATIATION": 0,
492         "T_COMMAND": 0,
493         "T_TYPE": type,
494         "T_POSY": 0,
495         "T_POSX": 0,
496         "T_CARRIES": [],
497         "carried": False,
498         "T_MEMTHING": [],
499         "T_MEMMAP": False,
500         "T_MEMDEPTHMAP": False,
501         "fovmap": False
502     }
503     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
504         build_fov_map(thing)
505     return thing
506
507
508 def id_setter(id, category, id_store=False, start_at_1=False):
509     """Set ID of object of category to manipulate ID unused? Create new one.
510
511     The ID is stored as id_store.id (if id_store is set). If the integer of the
512     input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
513     32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
514     >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
515     new object is created, otherwise the new object's ID.
516     """
517     min = 0 if start_at_1 else -32768
518     max = 255 if start_at_1 else 32767
519     if str == type(id):
520         id = integer_test(id, min, max)
521     if None != id:
522         if id in world_db[category]:
523             if id_store:
524                 id_store.id = id
525             return None
526         else:
527             if (start_at_1 and 0 == id) \
528                or ((not start_at_1) and (id < 0 or id > 255)):
529                 id = -1
530                 while 1:
531                     id = id + 1
532                     if id not in world_db[category]:
533                         break
534                 if id > 255:
535                     print("Ignoring: "
536                           "No unused ID available to add to ID list.")
537                     return None
538             if id_store:
539                 id_store.id = id
540     return id
541
542
543 def command_ping():
544     """Send PONG line to server output file."""
545     strong_write(io_db["file_out"], "PONG\n")
546
547
548 def command_quit():
549     """Abort server process."""
550     raise SystemExit("received QUIT command")
551
552
553 def command_thingshere(str_y, str_x):
554     """Write to out file list of Things known to player at coordinate y, x."""
555     def write_thing_if_here():
556         if y == world_db["Things"][id]["T_POSY"] \
557            and x == world_db["Things"][id]["T_POSX"]:
558             type = world_db["Things"][id]["T_TYPE"]
559             name = world_db["ThingTypes"][type]["TT_NAME"]
560             strong_write(io_db["file_out"], name + "\n")
561     if world_db["WORLD_ACTIVE"]:
562         y = integer_test(str_y, 0, 255)
563         x = integer_test(str_x, 0, 255)
564         length = world_db["MAP_LENGTH"]
565         if None != y and None != x and y < length and x < length:
566             pos = (y * world_db["MAP_LENGTH"]) + x
567             strong_write(io_db["file_out"], "THINGS_HERE START\n")
568             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
569                 for id in world_db["Things"]:
570                     write_thing_if_here()
571             else:
572                 for id in world_db["Things"]["T_MEMTHING"]:
573                     write_thing_if_here()
574             strong_write(io_db["file_out"], "THINGS_HERE END\n")
575         else:
576             print("Ignoring: Invalid map coordinates.")
577     else:
578         print("Ignoring: Command only works on existing worlds.")
579
580
581 def play_commander(action, args=False):
582     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
583
584     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
585     """
586
587     def set_command():
588         id = [x for x in world_db["ThingActions"]
589                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
590         world_db["Things"][0]["T_COMMAND"] = id
591         turn_over()
592         # TODO: call turn_over()
593
594     def set_command_and_argument_int(str_arg):
595         val = integer_test(str_arg, 0, 255)
596         if None != val:
597             world_db["Things"][0]["T_ARGUMENT"] = val
598             set_command()
599         else:
600             print("Ignoring: Argument must be integer >= 0 <=255.")
601
602     def set_command_and_argument_movestring(str_arg):
603         dirs = {"east": "d", "south-east": "c", "south-west": "x",
604                 "west": "s", "north-west": "w", "north-east": "e"}
605         if str_arg in dirs:
606             world_db["Things"][0]["T_ARGUMENT"] = dirs[str_arg]
607             set_command()
608         else:
609             print("Ignoring: Argument must be valid direction string.")
610
611     if action == "move":
612         return set_command_and_argument_movestring
613     elif args:
614         return set_command_and_argument_int
615     else:
616         return set_command
617
618
619 def command_seedmap(seed_string):
620     """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
621     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
622     remake_map()
623
624
625 def command_makeworld(seed_string):
626     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
627
628     Make seed world_db["SEED_RANDOMNESS"] and world_db["SEED_MAP"]. Do more
629     only with a "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType
630     of TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
631     and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
632     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
633     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
634     other. Init player's memory map. Write "NEW_WORLD" line to out file.
635     """
636     setter(None, "SEED_RANDOMNESS", 0, 4294967295)(seed_string)
637     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
638     player_will_be_generated = False
639     playertype = world_db["PLAYER_TYPE"]
640     for ThingType in world_db["ThingTypes"]:
641         if playertype == ThingType:
642             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
643                 player_will_be_generated = True
644             break
645     if not player_will_be_generated:
646         print("Ignoring beyond SEED_MAP: " +
647               "No player type with start number >0 defined.")
648         return
649     wait_action = False
650     for ThingAction in world_db["ThingActions"]:
651         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
652             wait_action = True
653     if not wait_action:
654         print("Ignoring beyond SEED_MAP: " +
655               "No thing action with name 'wait' defined.")
656         return
657     world_db["Things"] = {}
658     remake_map()
659     world_db["WORLD_ACTIVE"] = 1
660     world_db["TURN"] = 1
661     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
662         id = id_setter(-1, "Things")
663         world_db["Things"][id] = new_Thing(playertype)
664     # TODO: Positioning.
665     update_map_memory(world_db["Things"][0])
666     for type in world_db["ThingTypes"]:
667         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
668             if type != playertype:
669                 id = id_setter(-1, "Things")
670                 world_db["Things"][id] = new_Thing(type)
671     # TODO: Positioning.
672     strong_write(io_db["file_out"], "NEW_WORLD\n")
673
674
675 def command_maplength(maplength_string):
676     """Redefine map length. Invalidate map, therefore lose all things on it."""
677     set_world_inactive()
678     world_db["Things"] = {}
679     setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
680
681
682 def command_worldactive(worldactive_string):
683     """Toggle world_db["WORLD_ACTIVE"] if possible.
684
685     An active world can always be set inactive. An inactive world can only be
686     set active with a "wait" ThingAction, and a player Thing (of ID 0). On
687     activation, rebuild all Things' FOVs, and the player's map memory.
688     """
689     # In original version, map existence was also tested (unnecessarily?).
690     val = integer_test(worldactive_string, 0, 1)
691     if val:
692         if 0 != world_db["WORLD_ACTIVE"]:
693             if 0 == val:
694                 set_world_inactive()
695             else:
696                 print("World already active.")
697         elif 0 == world_db["WORLD_ACTIVE"]:
698             wait_exists = False
699             for ThingAction in world_db["ThingActions"]:
700                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
701                     wait_exists = True
702                     break
703             player_exists = False
704             for Thing in world_db["Things"]:
705                 if 0 == Thing:
706                     player_exists = True
707                     break
708             if wait_exists and player_exists:
709                 for id in world_db["Things"]:
710                     if world_db["Things"][id]["T_LIFEPOINTS"]:
711                         build_fov_map(world_db["Things"][id])
712                         if 0 == id:
713                             update_map_memory(world_db["Things"][id])
714                 world_db["WORLD_ACTIVE"] = 1
715
716
717 def test_for_id_maker(object, category):
718     """Return decorator testing for object having "id" attribute."""
719     def decorator(f):
720         def helper(*args):
721             if hasattr(object, "id"):
722                 f(*args)
723             else:
724                 print("Ignoring: No " + category +
725                       " defined to manipulate yet.")
726         return helper
727     return decorator
728
729
730 def command_tid(id_string):
731     """Set ID of Thing to manipulate. ID unused? Create new one.
732
733     Default new Thing's type to the first available ThingType, others: zero.
734     """
735     id = id_setter(id_string, "Things", command_tid)
736     if None != id:
737         if world_db["ThingTypes"] == {}:
738             print("Ignoring: No ThingType to settle new Thing in.")
739             return
740         type = list(world_db["ThingTypes"].keys())[0]
741         world_db["Things"][id] = new_Thing(type)
742
743
744 test_Thing_id = test_for_id_maker(command_tid, "Thing")
745
746
747 @test_Thing_id
748 def command_tcommand(str_int):
749     """Set T_COMMAND of selected Thing."""
750     val = integer_test(str_int, 0, 255)
751     if None != val:
752         if 0 == val or val in world_db["ThingActions"]:
753             world_db["Things"][command_tid.id]["T_COMMAND"] = val
754         else:
755             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
756
757
758 @test_Thing_id
759 def command_ttype(str_int):
760     """Set T_TYPE of selected Thing."""
761     val = integer_test(str_int, 0, 255)
762     if None != val:
763         if val in world_db["ThingTypes"]:
764             world_db["Things"][command_tid.id]["T_TYPE"] = val
765         else:
766             print("Ignoring: ThingType ID belongs to no known ThingType.")
767
768
769 @test_Thing_id
770 def command_tcarries(str_int):
771     """Append int(str_int) to T_CARRIES of selected Thing.
772
773     The ID int(str_int) must not be of the selected Thing, and must belong to a
774     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
775     """
776     val = integer_test(str_int, 0, 255)
777     if None != val:
778         if val == command_tid.id:
779             print("Ignoring: Thing cannot carry itself.")
780         elif val in world_db["Things"] \
781              and not world_db["Things"][val]["carried"]:
782             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
783             world_db["Things"][val]["carried"] = True
784         else:
785             print("Ignoring: Thing not available for carrying.")
786     # Note that the whole carrying structure is different from the C version:
787     # Carried-ness is marked by a "carried" flag, not by Things containing
788     # Things internally.
789
790
791 @test_Thing_id
792 def command_tmemthing(str_t, str_y, str_x):
793     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
794
795     The type must fit to an existing ThingType, and the position into the map.
796     """
797     type = integer_test(str_t, 0, 255)
798     posy = integer_test(str_y, 0, 255)
799     posx = integer_test(str_x, 0, 255)
800     if None != type and None != posy and None != posx:
801         if type not in world_db["ThingTypes"] \
802            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
803             print("Ignoring: Illegal value for thing type or position.")
804         else:
805             memthing = (type, posy, posx)
806             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
807
808
809 def setter_map(maptype):
810     """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
811
812     If Thing has no map of maptype yet, initialize it with ' ' bytes first.
813     """
814     @test_Thing_id
815     def helper(str_int, mapline):
816         val = integer_test(str_int, 0, 255)
817         if None != val:
818             if val >= world_db["MAP_LENGTH"]:
819                 print("Illegal value for map line number.")
820             elif len(mapline) != world_db["MAP_LENGTH"]:
821                 print("Map line length is unequal map width.")
822             else:
823                 length = world_db["MAP_LENGTH"]
824                 map = None
825                 if not world_db["Things"][command_tid.id][maptype]:
826                     map = bytearray(b' ' * (length ** 2))
827                 else:
828                     map = world_db["Things"][command_tid.id][maptype]
829                 map[val * length:(val * length) + length] = mapline.encode()
830                 world_db["Things"][command_tid.id][maptype] = map
831     return helper
832
833
834 def setter_tpos(axis):
835     """Generate setter for T_POSX or  T_POSY of selected Thing.
836
837     If world is active, rebuilds animate things' fovmap, player's memory map.
838     """
839     @test_Thing_id
840     def helper(str_int):
841         val = integer_test(str_int, 0, 255)
842         if None != val:
843             if val < world_db["MAP_LENGTH"]:
844                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
845                 if world_db["WORLD_ACTIVE"] \
846                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
847                     build_fov_map(world_db["Things"][command_tid.id])
848                     if 0 == command_tid.id:
849                         update_map_memory(world_db["Things"][command_tid.id])
850             else:
851                 print("Ignoring: Position is outside of map.")
852     return helper
853
854
855 def command_ttid(id_string):
856     """Set ID of ThingType to manipulate. ID unused? Create new one.
857
858     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
859     """
860     id = id_setter(id_string, "ThingTypes", command_ttid)
861     if None != id:
862         world_db["ThingTypes"][id] = {
863             "TT_NAME": "(none)",
864             "TT_CONSUMABLE": 0,
865             "TT_LIFEPOINTS": 0,
866             "TT_PROLIFERATE": 0,
867             "TT_START_NUMBER": 0,
868             "TT_SYMBOL": "?",
869             "TT_CORPSE_ID": id
870         }
871
872
873 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
874
875
876 @test_ThingType_id
877 def command_ttname(name):
878     """Set TT_NAME of selected ThingType."""
879     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
880
881
882 @test_ThingType_id
883 def command_ttsymbol(char):
884     """Set TT_SYMBOL of selected ThingType. """
885     if 1 == len(char):
886         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
887     else:
888         print("Ignoring: Argument must be single character.")
889
890
891 @test_ThingType_id
892 def command_ttcorpseid(str_int):
893     """Set TT_CORPSE_ID of selected ThingType."""
894     val = integer_test(str_int, 0, 255)
895     if None != val:
896         if val in world_db["ThingTypes"]:
897             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
898         else:
899             print("Ignoring: Corpse ID belongs to no known ThignType.")
900
901
902 def command_taid(id_string):
903     """Set ID of ThingAction to manipulate. ID unused? Create new one.
904
905     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
906     """
907     id = id_setter(id_string, "ThingActions", command_taid, True)
908     if None != id:
909         world_db["ThingActions"][id] = {
910             "TA_EFFORT": 1,
911             "TA_NAME": "wait"
912         }
913
914
915 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
916
917
918 @test_ThingAction_id
919 def command_taname(name):
920     """Set TA_NAME of selected ThingAction.
921
922     The name must match a valid thing action function. If after the name
923     setting no ThingAction with name "wait" remains, call set_world_inactive().
924     """
925     if name == "wait" or name == "move" or name == "use" or name == "drop" \
926        or name == "pick_up":
927         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
928         if 1 == world_db["WORLD_ACTIVE"]:
929             wait_defined = False
930             for id in world_db["ThingActions"]:
931                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
932                     wait_defined = True
933                     break
934             if not wait_defined:
935                 set_world_inactive()
936     else:
937         print("Ignoring: Invalid action name.")
938     # In contrast to the original,naming won't map a function to a ThingAction.
939
940
941 """Commands database.
942
943 Map command start tokens to ([0]) number of expected command arguments, ([1])
944 the command's meta-ness (i.e. is it to be written to the record file, is it to
945 be ignored in replay mode if read from server input file), and ([2]) a function
946 to be called on it.
947 """
948 commands_db = {
949     "QUIT": (0, True, command_quit),
950     "PING": (0, True, command_ping),
951     "THINGS_HERE": (2, True, command_thingshere),
952     "MAKE_WORLD": (1, False, command_makeworld),
953     "SEED_MAP": (1, False, command_seedmap),
954     "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS",
955                                          0, 4294967295)),
956     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
957     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
958     "MAP_LENGTH": (1, False, command_maplength),
959     "WORLD_ACTIVE": (1, False, command_worldactive),
960     "TA_ID": (1, False, command_taid),
961     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
962     "TA_NAME": (1, False, command_taname),
963     "TT_ID": (1, False, command_ttid),
964     "TT_NAME": (1, False, command_ttname),
965     "TT_SYMBOL": (1, False, command_ttsymbol),
966     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
967     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
968                                        0, 65535)),
969     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
970                                          0, 255)),
971     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
972                                         0, 255)),
973     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
974     "T_ID": (1, False, command_tid),
975     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
976     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
977     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
978     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
979     "T_COMMAND": (1, False, command_tcommand),
980     "T_TYPE": (1, False, command_ttype),
981     "T_CARRIES": (1, False, command_tcarries),
982     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
983     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
984     "T_MEMTHING": (3, False, command_tmemthing),
985     "T_POSY": (1, False, setter_tpos("Y")),
986     "T_POSX": (1, False, setter_tpos("X")),
987     "wait": (0, False, play_commander("wait")),
988     "move": (1, False, play_commander("move")),
989     "pick_up": (0, False, play_commander("pick_up")),
990     "drop": (1, False, play_commander("drop", True)),
991     "use": (1, False, play_commander("use", True)),
992 }
993
994
995 """World state database. With sane default values."""
996 world_db = {
997     "TURN": 0,
998     "SEED_MAP": 0,
999     "SEED_RANDOMNESS": 0,
1000     "PLAYER_TYPE": 0,
1001     "MAP_LENGTH": 64,
1002     "WORLD_ACTIVE": 0,
1003     "ThingActions": {},
1004     "ThingTypes": {},
1005     "Things": {}
1006 }
1007
1008
1009 """File IO database."""
1010 io_db = {
1011     "path_save": "save",
1012     "path_record": "record",
1013     "path_worldconf": "confserver/world",
1014     "path_server": "server/",
1015     "path_in": "server/in",
1016     "path_out": "server/out",
1017     "path_worldstate": "server/worldstate",
1018     "tmp_suffix": "_tmp",
1019     "kicked_by_rival": False,
1020     "worldstate_updateable": False
1021 }
1022
1023
1024 try:
1025     opts = parse_command_line_arguments()
1026     setup_server_io()
1027     if None != opts.replay:
1028         replay_game()
1029     else:
1030         play_game()
1031 except SystemExit as exit:
1032     print("ABORTING: " + exit.args[0])
1033 except:
1034     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1035     raise
1036 finally:
1037     cleanup_server_io()