home · contact · privacy
2121c75ad2cf15988c240544b10da159e37d0d0c
[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     print("turning over")
456     whilebreaker = False
457     while world_db["Things"][0]["T_LIFEPOINTS"]:
458         for id in [id for id in world_db["Things"]
459                       if not world_db["Things"][id]["carried"]
460                       if world_db["Things"][id]["T_LIFEPOINTS"]]:
461             print(str(id))
462             Thing = world_db["Things"][id]
463             if Thing["T_LIFEPOINTS"]:
464                 print("  evaluating thing")
465                 if not Thing["T_COMMAND"]:
466                     print("    thing needs new command")
467                     update_map_memory(Thing)
468                     if 0 == id:
469                         whilebreaker = True
470                         break
471                     # DUMMY: ai(thing)
472                     print("    run AI")
473                     Thing["T_COMMAND"] = 1
474                 # DUMMY: try_healing
475                 Thing["T_PROGRESS"] += 1
476                 taid = [a for a in world_db["ThingActions"]
477                           if a == Thing["T_COMMAND"]][0]
478                 ThingAction = world_db["ThingActions"][taid]
479                 if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
480                     print("  running thing action")
481                     # run_thing_action(action["TA_NAME"])
482                     Thing["T_COMMAND"] = 0
483                     Thing["T_PROGRESS"] = 0
484                 # DUMMY: hunger
485             # DUMMY: thingproliferation
486         if whilebreaker:
487             break
488         print("  turn finished")
489         world_db["TURN"] += 1
490         print("  new turn " + str(world_db["TURN"]))
491
492
493 def new_Thing(type):
494     """Return Thing of type T_TYPE, with fovmap if alive and world active."""
495     thing = {
496         "T_LIFEPOINTS": world_db["ThingTypes"][type]["TT_LIFEPOINTS"],
497         "T_ARGUMENT": 0,
498         "T_PROGRESS": 0,
499         "T_SATIATION": 0,
500         "T_COMMAND": 0,
501         "T_TYPE": type,
502         "T_POSY": 0,
503         "T_POSX": 0,
504         "T_CARRIES": [],
505         "carried": False,
506         "T_MEMTHING": [],
507         "T_MEMMAP": False,
508         "T_MEMDEPTHMAP": False,
509         "fovmap": False
510     }
511     if world_db["WORLD_ACTIVE"] and thing["T_LIFEPOINTS"]:
512         build_fov_map(thing)
513     return thing
514
515
516 def id_setter(id, category, id_store=False, start_at_1=False):
517     """Set ID of object of category to manipulate ID unused? Create new one.
518
519     The ID is stored as id_store.id (if id_store is set). If the integer of the
520     input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
521     32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
522     >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
523     new object is created, otherwise the new object's ID.
524     """
525     min = 0 if start_at_1 else -32768
526     max = 255 if start_at_1 else 32767
527     if str == type(id):
528         id = integer_test(id, min, max)
529     if None != id:
530         if id in world_db[category]:
531             if id_store:
532                 id_store.id = id
533             return None
534         else:
535             if (start_at_1 and 0 == id) \
536                or ((not start_at_1) and (id < 0 or id > 255)):
537                 id = -1
538                 while 1:
539                     id = id + 1
540                     if id not in world_db[category]:
541                         break
542                 if id > 255:
543                     print("Ignoring: "
544                           "No unused ID available to add to ID list.")
545                     return None
546             if id_store:
547                 id_store.id = id
548     return id
549
550
551 def command_ping():
552     """Send PONG line to server output file."""
553     strong_write(io_db["file_out"], "PONG\n")
554
555
556 def command_quit():
557     """Abort server process."""
558     raise SystemExit("received QUIT command")
559
560
561 def command_thingshere(str_y, str_x):
562     """Write to out file list of Things known to player at coordinate y, x."""
563     def write_thing_if_here():
564         if y == world_db["Things"][id]["T_POSY"] \
565            and x == world_db["Things"][id]["T_POSX"]:
566             type = world_db["Things"][id]["T_TYPE"]
567             name = world_db["ThingTypes"][type]["TT_NAME"]
568             strong_write(io_db["file_out"], name + "\n")
569     if world_db["WORLD_ACTIVE"]:
570         y = integer_test(str_y, 0, 255)
571         x = integer_test(str_x, 0, 255)
572         length = world_db["MAP_LENGTH"]
573         if None != y and None != x and y < length and x < length:
574             pos = (y * world_db["MAP_LENGTH"]) + x
575             strong_write(io_db["file_out"], "THINGS_HERE START\n")
576             if "v" == chr(world_db["Things"][0]["fovmap"][pos]):
577                 for id in world_db["Things"]:
578                     write_thing_if_here()
579             else:
580                 for id in world_db["Things"]["T_MEMTHING"]:
581                     write_thing_if_here()
582             strong_write(io_db["file_out"], "THINGS_HERE END\n")
583         else:
584             print("Ignoring: Invalid map coordinates.")
585     else:
586         print("Ignoring: Command only works on existing worlds.")
587
588
589 def play_commander(action, args=False):
590     """Setter for player's T_COMMAND and T_ARGUMENT, then calling turn_over().
591
592     T_ARGUMENT is set to direction char if action=="wait",or 8-bit int if args.
593     """
594
595     def set_command():
596         id = [x for x in world_db["ThingActions"]
597                 if world_db["ThingActions"][x]["TA_NAME"] == action][0]
598         world_db["Things"][0]["T_COMMAND"] = id
599         turn_over()
600         # TODO: call turn_over()
601
602     def set_command_and_argument_int(str_arg):
603         val = integer_test(str_arg, 0, 255)
604         if None != val:
605             world_db["Things"][0]["T_ARGUMENT"] = val
606             set_command()
607         else:
608             print("Ignoring: Argument must be integer >= 0 <=255.")
609
610     def set_command_and_argument_movestring(str_arg):
611         dirs = {"east": "d", "south-east": "c", "south-west": "x",
612                 "west": "s", "north-west": "w", "north-east": "e"}
613         if str_arg in dirs:
614             world_db["Things"][0]["T_ARGUMENT"] = dirs[str_arg]
615             set_command()
616         else:
617             print("Ignoring: Argument must be valid direction string.")
618
619     if action == "move":
620         return set_command_and_argument_movestring
621     elif args:
622         return set_command_and_argument_int
623     else:
624         return set_command
625
626
627 def command_seedmap(seed_string):
628     """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
629     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
630     remake_map()
631
632
633 def command_makeworld(seed_string):
634     """(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
635
636     Make seed world_db["SEED_RANDOMNESS"] and world_db["SEED_MAP"]. Do more
637     only with a "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType
638     of TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
639     and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
640     according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
641     of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
642     other. Init player's memory map. Write "NEW_WORLD" line to out file.
643     """
644     setter(None, "SEED_RANDOMNESS", 0, 4294967295)(seed_string)
645     setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
646     player_will_be_generated = False
647     playertype = world_db["PLAYER_TYPE"]
648     for ThingType in world_db["ThingTypes"]:
649         if playertype == ThingType:
650             if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
651                 player_will_be_generated = True
652             break
653     if not player_will_be_generated:
654         print("Ignoring beyond SEED_MAP: " +
655               "No player type with start number >0 defined.")
656         return
657     wait_action = False
658     for ThingAction in world_db["ThingActions"]:
659         if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
660             wait_action = True
661     if not wait_action:
662         print("Ignoring beyond SEED_MAP: " +
663               "No thing action with name 'wait' defined.")
664         return
665     world_db["Things"] = {}
666     remake_map()
667     world_db["WORLD_ACTIVE"] = 1
668     world_db["TURN"] = 1
669     for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
670         id = id_setter(-1, "Things")
671         world_db["Things"][id] = new_Thing(playertype)
672     # TODO: Positioning.
673     update_map_memory(world_db["Things"][0])
674     for type in world_db["ThingTypes"]:
675         for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
676             if type != playertype:
677                 id = id_setter(-1, "Things")
678                 world_db["Things"][id] = new_Thing(type)
679     # TODO: Positioning.
680     strong_write(io_db["file_out"], "NEW_WORLD\n")
681
682
683 def command_maplength(maplength_string):
684     """Redefine map length. Invalidate map, therefore lose all things on it."""
685     set_world_inactive()
686     world_db["Things"] = {}
687     setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
688
689
690 def command_worldactive(worldactive_string):
691     """Toggle world_db["WORLD_ACTIVE"] if possible.
692
693     An active world can always be set inactive. An inactive world can only be
694     set active with a "wait" ThingAction, and a player Thing (of ID 0). On
695     activation, rebuild all Things' FOVs, and the player's map memory.
696     """
697     # In original version, map existence was also tested (unnecessarily?).
698     val = integer_test(worldactive_string, 0, 1)
699     if val:
700         if 0 != world_db["WORLD_ACTIVE"]:
701             if 0 == val:
702                 set_world_inactive()
703             else:
704                 print("World already active.")
705         elif 0 == world_db["WORLD_ACTIVE"]:
706             wait_exists = False
707             for ThingAction in world_db["ThingActions"]:
708                 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
709                     wait_exists = True
710                     break
711             player_exists = False
712             for Thing in world_db["Things"]:
713                 if 0 == Thing:
714                     player_exists = True
715                     break
716             if wait_exists and player_exists:
717                 for id in world_db["Things"]:
718                     if world_db["Things"][id]["T_LIFEPOINTS"]:
719                         build_fov_map(world_db["Things"][id])
720                         if 0 == id:
721                             update_map_memory(world_db["Things"][id])
722                 world_db["WORLD_ACTIVE"] = 1
723
724
725 def test_for_id_maker(object, category):
726     """Return decorator testing for object having "id" attribute."""
727     def decorator(f):
728         def helper(*args):
729             if hasattr(object, "id"):
730                 f(*args)
731             else:
732                 print("Ignoring: No " + category +
733                       " defined to manipulate yet.")
734         return helper
735     return decorator
736
737
738 def command_tid(id_string):
739     """Set ID of Thing to manipulate. ID unused? Create new one.
740
741     Default new Thing's type to the first available ThingType, others: zero.
742     """
743     id = id_setter(id_string, "Things", command_tid)
744     if None != id:
745         if world_db["ThingTypes"] == {}:
746             print("Ignoring: No ThingType to settle new Thing in.")
747             return
748         type = list(world_db["ThingTypes"].keys())[0]
749         world_db["Things"][id] = new_Thing(type)
750
751
752 test_Thing_id = test_for_id_maker(command_tid, "Thing")
753
754
755 @test_Thing_id
756 def command_tcommand(str_int):
757     """Set T_COMMAND of selected Thing."""
758     val = integer_test(str_int, 0, 255)
759     if None != val:
760         if 0 == val or val in world_db["ThingActions"]:
761             world_db["Things"][command_tid.id]["T_COMMAND"] = val
762         else:
763             print("Ignoring: ThingAction ID belongs to no known ThingAction.")
764
765
766 @test_Thing_id
767 def command_ttype(str_int):
768     """Set T_TYPE of selected Thing."""
769     val = integer_test(str_int, 0, 255)
770     if None != val:
771         if val in world_db["ThingTypes"]:
772             world_db["Things"][command_tid.id]["T_TYPE"] = val
773         else:
774             print("Ignoring: ThingType ID belongs to no known ThingType.")
775
776
777 @test_Thing_id
778 def command_tcarries(str_int):
779     """Append int(str_int) to T_CARRIES of selected Thing.
780
781     The ID int(str_int) must not be of the selected Thing, and must belong to a
782     Thing with unset "carried" flag. Its "carried" flag will be set on owning.
783     """
784     val = integer_test(str_int, 0, 255)
785     if None != val:
786         if val == command_tid.id:
787             print("Ignoring: Thing cannot carry itself.")
788         elif val in world_db["Things"] \
789              and not world_db["Things"][val]["carried"]:
790             world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
791             world_db["Things"][val]["carried"] = True
792         else:
793             print("Ignoring: Thing not available for carrying.")
794     # Note that the whole carrying structure is different from the C version:
795     # Carried-ness is marked by a "carried" flag, not by Things containing
796     # Things internally.
797
798
799 @test_Thing_id
800 def command_tmemthing(str_t, str_y, str_x):
801     """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
802
803     The type must fit to an existing ThingType, and the position into the map.
804     """
805     type = integer_test(str_t, 0, 255)
806     posy = integer_test(str_y, 0, 255)
807     posx = integer_test(str_x, 0, 255)
808     if None != type and None != posy and None != posx:
809         if type not in world_db["ThingTypes"] \
810            or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
811             print("Ignoring: Illegal value for thing type or position.")
812         else:
813             memthing = (type, posy, posx)
814             world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
815
816
817 def setter_map(maptype):
818     """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
819
820     If Thing has no map of maptype yet, initialize it with ' ' bytes first.
821     """
822     @test_Thing_id
823     def helper(str_int, mapline):
824         val = integer_test(str_int, 0, 255)
825         if None != val:
826             if val >= world_db["MAP_LENGTH"]:
827                 print("Illegal value for map line number.")
828             elif len(mapline) != world_db["MAP_LENGTH"]:
829                 print("Map line length is unequal map width.")
830             else:
831                 length = world_db["MAP_LENGTH"]
832                 map = None
833                 if not world_db["Things"][command_tid.id][maptype]:
834                     map = bytearray(b' ' * (length ** 2))
835                 else:
836                     map = world_db["Things"][command_tid.id][maptype]
837                 map[val * length:(val * length) + length] = mapline.encode()
838                 world_db["Things"][command_tid.id][maptype] = map
839     return helper
840
841
842 def setter_tpos(axis):
843     """Generate setter for T_POSX or  T_POSY of selected Thing.
844
845     If world is active, rebuilds animate things' fovmap, player's memory map.
846     """
847     @test_Thing_id
848     def helper(str_int):
849         val = integer_test(str_int, 0, 255)
850         if None != val:
851             if val < world_db["MAP_LENGTH"]:
852                 world_db["Things"][command_tid.id]["T_POS" + axis] = val
853                 if world_db["WORLD_ACTIVE"] \
854                    and world_db["Things"][command_tid.id]["T_LIFEPOINTS"]:
855                     build_fov_map(world_db["Things"][command_tid.id])
856                     if 0 == command_tid.id:
857                         update_map_memory(world_db["Things"][command_tid.id])
858             else:
859                 print("Ignoring: Position is outside of map.")
860     return helper
861
862
863 def command_ttid(id_string):
864     """Set ID of ThingType to manipulate. ID unused? Create new one.
865
866     Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
867     """
868     id = id_setter(id_string, "ThingTypes", command_ttid)
869     if None != id:
870         world_db["ThingTypes"][id] = {
871             "TT_NAME": "(none)",
872             "TT_CONSUMABLE": 0,
873             "TT_LIFEPOINTS": 0,
874             "TT_PROLIFERATE": 0,
875             "TT_START_NUMBER": 0,
876             "TT_SYMBOL": "?",
877             "TT_CORPSE_ID": id
878         }
879
880
881 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
882
883
884 @test_ThingType_id
885 def command_ttname(name):
886     """Set TT_NAME of selected ThingType."""
887     world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
888
889
890 @test_ThingType_id
891 def command_ttsymbol(char):
892     """Set TT_SYMBOL of selected ThingType. """
893     if 1 == len(char):
894         world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
895     else:
896         print("Ignoring: Argument must be single character.")
897
898
899 @test_ThingType_id
900 def command_ttcorpseid(str_int):
901     """Set TT_CORPSE_ID of selected ThingType."""
902     val = integer_test(str_int, 0, 255)
903     if None != val:
904         if val in world_db["ThingTypes"]:
905             world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
906         else:
907             print("Ignoring: Corpse ID belongs to no known ThignType.")
908
909
910 def command_taid(id_string):
911     """Set ID of ThingAction to manipulate. ID unused? Create new one.
912
913     Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
914     """
915     id = id_setter(id_string, "ThingActions", command_taid, True)
916     if None != id:
917         world_db["ThingActions"][id] = {
918             "TA_EFFORT": 1,
919             "TA_NAME": "wait"
920         }
921
922
923 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
924
925
926 @test_ThingAction_id
927 def command_taname(name):
928     """Set TA_NAME of selected ThingAction.
929
930     The name must match a valid thing action function. If after the name
931     setting no ThingAction with name "wait" remains, call set_world_inactive().
932     """
933     if name == "wait" or name == "move" or name == "use" or name == "drop" \
934        or name == "pick_up":
935         world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
936         if 1 == world_db["WORLD_ACTIVE"]:
937             wait_defined = False
938             for id in world_db["ThingActions"]:
939                 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
940                     wait_defined = True
941                     break
942             if not wait_defined:
943                 set_world_inactive()
944     else:
945         print("Ignoring: Invalid action name.")
946     # In contrast to the original,naming won't map a function to a ThingAction.
947
948
949 """Commands database.
950
951 Map command start tokens to ([0]) number of expected command arguments, ([1])
952 the command's meta-ness (i.e. is it to be written to the record file, is it to
953 be ignored in replay mode if read from server input file), and ([2]) a function
954 to be called on it.
955 """
956 commands_db = {
957     "QUIT": (0, True, command_quit),
958     "PING": (0, True, command_ping),
959     "THINGS_HERE": (2, True, command_thingshere),
960     "MAKE_WORLD": (1, False, command_makeworld),
961     "SEED_MAP": (1, False, command_seedmap),
962     "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS",
963                                          0, 4294967295)),
964     "TURN": (1, False, setter(None, "TURN", 0, 65535)),
965     "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
966     "MAP_LENGTH": (1, False, command_maplength),
967     "WORLD_ACTIVE": (1, False, command_worldactive),
968     "TA_ID": (1, False, command_taid),
969     "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
970     "TA_NAME": (1, False, command_taname),
971     "TT_ID": (1, False, command_ttid),
972     "TT_NAME": (1, False, command_ttname),
973     "TT_SYMBOL": (1, False, command_ttsymbol),
974     "TT_CORPSE_ID": (1, False, command_ttcorpseid),
975     "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
976                                        0, 65535)),
977     "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
978                                          0, 255)),
979     "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
980                                         0, 255)),
981     "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
982     "T_ID": (1, False, command_tid),
983     "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
984     "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
985     "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
986     "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
987     "T_COMMAND": (1, False, command_tcommand),
988     "T_TYPE": (1, False, command_ttype),
989     "T_CARRIES": (1, False, command_tcarries),
990     "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
991     "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
992     "T_MEMTHING": (3, False, command_tmemthing),
993     "T_POSY": (1, False, setter_tpos("Y")),
994     "T_POSX": (1, False, setter_tpos("X")),
995     "wait": (0, False, play_commander("wait")),
996     "move": (1, False, play_commander("move")),
997     "pick_up": (0, False, play_commander("pick_up")),
998     "drop": (1, False, play_commander("drop", True)),
999     "use": (1, False, play_commander("use", True)),
1000 }
1001
1002
1003 """World state database. With sane default values."""
1004 world_db = {
1005     "TURN": 0,
1006     "SEED_MAP": 0,
1007     "SEED_RANDOMNESS": 0,
1008     "PLAYER_TYPE": 0,
1009     "MAP_LENGTH": 64,
1010     "WORLD_ACTIVE": 0,
1011     "ThingActions": {},
1012     "ThingTypes": {},
1013     "Things": {}
1014 }
1015
1016
1017 """File IO database."""
1018 io_db = {
1019     "path_save": "save",
1020     "path_record": "record",
1021     "path_worldconf": "confserver/world",
1022     "path_server": "server/",
1023     "path_in": "server/in",
1024     "path_out": "server/out",
1025     "path_worldstate": "server/worldstate",
1026     "tmp_suffix": "_tmp",
1027     "kicked_by_rival": False,
1028     "worldstate_updateable": False
1029 }
1030
1031
1032 try:
1033     opts = parse_command_line_arguments()
1034     setup_server_io()
1035     if None != opts.replay:
1036         replay_game()
1037     else:
1038         play_game()
1039 except SystemExit as exit:
1040     print("ABORTING: " + exit.args[0])
1041 except:
1042     print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
1043     raise
1044 finally:
1045     cleanup_server_io()