9 def strong_write(file, string):
10 """Apply write(string), flush() and os.fsync() to file."""
16 def setup_server_io():
17 """Fill IO files DB with proper file( path)s. Write process IO test string.
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"].
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):
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"])
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):
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()
60 def obey(command, prefix, replay=False, do_record=False):
61 """Call function from commands_db mapped to command's first token.
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.
72 print("input " + prefix + ": " + command)
74 tokens = shlex.split(command, comments=True)
75 except ValueError as err:
76 print("Can't tokenize command string: " + str(err) + ".")
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:])
83 print("Due to replay mode, reading command as 'go on in record'.")
84 line = io_db["file_record"].readline()
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
90 print("Reached end of record file.")
92 commands_db[tokens[0]][2](*tokens[1:])
96 io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
97 elif 0 != len(tokens):
98 print("Invalid command/argument, or bad number of tokens.")
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"]
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)
112 if os.access(path, os.F_OK):
114 os.rename(path_tmp, path)
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)
126 """Save all commands needed to reconstruct current world state."""
127 # TODO: Misses same optimizations as record() from the original record().
130 string = string.replace("\u005C", '\u005C\u005C')
131 return '"' + string.replace('"', '\u005C"') + '"'
136 if world_db["Things"][id][key]:
137 rmap = world_db["Things"][id][key]
138 length = world_db["MAP_LENGTH"]
139 for i in range(length):
140 line = rmap[i * length:(i * length) + length].decode()
141 string = string + key + " " + str(i) + quote(line) + "\n"
147 for memthing in world_db["Things"][id]["T_MEMTHING"]:
148 string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
149 str(memthing[1]) + " " + str(memthing[2]) + "\n"
152 def helper(category, id_string, special_keys={}):
154 for id in world_db[category]:
155 string = string + id_string + " " + str(id) + "\n"
156 for key in world_db[category][id]:
157 if not key in special_keys:
158 x = world_db[category][id][key]
159 argument = quote(x) if str == type(x) else str(x)
160 string = string + key + " " + argument + "\n"
161 elif special_keys[key]:
162 string = string + special_keys[key](id)
167 if dict != type(world_db[key]) and key != "MAP":
168 string = string + key + " " + str(world_db[key]) + "\n"
169 string = string + helper("ThingActions", "TA_ID")
170 string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
171 for id in world_db["ThingTypes"]:
172 string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
173 str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
174 string = string + helper("Things", "T_ID",
175 {"T_CARRIES": False, "carried": False,
176 "T_MEMMAP": mapsetter("T_MEMMAP"),
177 "T_MEMTHING": memthing,
178 "T_MEMDEPTHMAP": mapsetter("T_MEMDEPTHMAP")})
179 for id in world_db["Things"]:
180 if [] != world_db["Things"][id]["T_CARRIES"]:
181 string = string + "T_ID " + str(id) + "\n"
182 for carried_id in world_db["Things"][id]["T_CARRIES"]:
183 string = string + "T_CARRIES " + str(carried_id) + "\n"
184 string = string + "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
185 atomic_write(io_db["path_save"], string)
188 def obey_lines_in_file(path, name, do_record=False):
189 """Call obey() on each line of path's file, use name in input prefix."""
190 file = open(path, "r")
192 for line in file.readlines():
193 obey(line.rstrip(), name + "file line " + str(line_n),
199 def parse_command_line_arguments():
200 """Return settings values read from command line arguments."""
201 parser = argparse.ArgumentParser()
202 parser.add_argument('-s', nargs='?', type=int, dest='replay', const=1,
204 opts, unknown = parser.parse_known_args()
209 """Ensure valid server out file belonging to current process.
211 This is done by comparing io_db["teststring"] to what's found at the start
212 of the current file at io_db["path_out"]. On failure, set
213 io_db["kicked_by_rival"] and raise SystemExit.
215 if not os.access(io_db["path_out"], os.F_OK):
216 raise SystemExit("Server output file has disappeared.")
217 file = open(io_db["path_out"], "r")
218 test = file.readline().rstrip("\n")
220 if test != io_db["teststring"]:
221 io_db["kicked_by_rival"] = True
222 msg = "Server test string in server output file does not match. This" \
223 " indicates that the current server process has been " \
224 "superseded by another one."
225 raise SystemExit(msg)
229 """Return next newline-delimited command from server in file.
231 Keep building return string until a newline is encountered. Pause between
232 unsuccessful reads, and after too much waiting, run server_test().
239 add = io_db["file_in"].readline()
241 command = command + add
242 if len(command) > 0 and "\n" == command[-1]:
243 command = command[:-1]
246 time.sleep(wait_on_fail)
247 if now + max_wait < time.time():
253 def try_worldstate_update():
254 """Write worldstate file if io_db["worldstate_updateable"] is set."""
255 if io_db["worldstate_updateable"]:
257 if [] == world_db["Things"][0]["T_CARRIES"]:
258 inventory = "(none)\n"
260 for id in world_db["Things"][0]["T_CARRIES"]:
261 type_id = world_db["Things"][id]["T_TYPE"]
262 name = world_db["ThingTypes"][type_id]["TT_NAME"]
263 inventory = inventory + name + "\n"
264 string = str(world_db["TURN"]) + "\n" + \
265 str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
266 str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
267 inventory + "%\n" + \
268 str(world_db["Things"][0]["T_POSY"]) + "\n" + \
269 str(world_db["Things"][0]["T_POSX"]) + "\n" + \
270 str(world_db["MAP_LENGTH"]) + "\n"
271 length = world_db["MAP_LENGTH"]
272 for i in range(length):
273 line = world_db["MAP"][i * length:(i * length) + length].decode()
274 string = string + line + "\n"
275 # TODO: no proper user-subjective map
276 atomic_write(io_db["path_worldstate"], string)
277 strong_write(io_db["file_out"], "WORLD_UPDATED\n")
278 io_db["worldstate_updateable"] = False
282 """Replay game from record file.
284 Use opts.replay as breakpoint turn to which to replay automatically before
285 switching to manual input by non-meta commands in server input file
286 triggering further reads of record file. Ensure opts.replay is at least 1.
287 Run try_worldstate_update() before each interactive obey()/read_command().
291 print("Replay mode. Auto-replaying up to turn " + str(opts.replay) +
292 " (if so late a turn is to be found).")
293 if not os.access(io_db["path_record"], os.F_OK):
294 raise SystemExit("No record file found to replay.")
295 io_db["file_record"] = open(io_db["path_record"], "r")
296 io_db["file_record"].prefix = "record file line "
297 io_db["file_record"].line_n = 1
298 while world_db["TURN"] < opts.replay:
299 line = io_db["file_record"].readline()
302 obey(line.rstrip(), io_db["file_record"].prefix
303 + str(io_db["file_record"].line_n))
304 io_db["file_record"].line_n = io_db["file_record"].line_n + 1
306 try_worldstate_update()
307 obey(read_command(), "in file", replay=True)
311 """Play game by server input file commands. Before, load save file found.
313 If no save file is found, a new world is generated from the commands in the
314 world config plus a 'MAKE WORLD [current Unix timestamp]'. Record this
315 command and all that follow via the server input file. Run
316 try_worldstate_update() before each interactive obey()/read_command().
318 if os.access(io_db["path_save"], os.F_OK):
319 obey_lines_in_file(io_db["path_save"], "save")
321 if not os.access(io_db["path_worldconf"], os.F_OK):
322 msg = "No world config file from which to start a new world."
323 raise SystemExit(msg)
324 obey_lines_in_file(io_db["path_worldconf"], "world config ",
326 obey("MAKE_WORLD " + str(int(time.time())), "in file", do_record=True)
328 try_worldstate_update()
329 obey(read_command(), "in file", do_record=True)
334 world_db["MAP"] = bytearray(b'.' * (world_db["MAP_LENGTH"] ** 2))
337 def set_world_inactive():
338 """Set world_db["WORLD_ACTIVE"] to 0 and remove worldstate file."""
340 if os.access(io_db["path_worldstate"], os.F_OK):
341 os.remove(io_db["path_worldstate"])
342 world_db["WORLD_ACTIVE"] = 0
345 def integer_test(val_string, min, max):
346 """Return val_string if possible integer >= min and <= max, else None."""
348 val = int(val_string)
349 if val < min or val > max:
353 print("Ignoring: Please use integer >= " + str(min) + " and <= " +
358 def setter(category, key, min, max):
359 """Build setter for world_db([category + "s"][id])[key] to >=min/<=max."""
362 val = integer_test(val_string, min, max)
366 if category == "Thing":
367 id_store = command_tid
368 decorator = test_Thing_id
369 elif category == "ThingType":
370 id_store = command_ttid
371 decorator = test_ThingType_id
372 elif category == "ThingAction":
373 id_store = command_taid
374 decorator = test_ThingAction_id
378 val = integer_test(val_string, min, max)
380 world_db[category + "s"][id_store.id][key] = val
384 def id_setter(id, category, id_store=False, start_at_1=False):
385 """Set ID of object of category to manipulate ID unused? Create new one.
387 The ID is stored as id_store.id (if id_store is set). If the integer of the
388 input is valid (if start_at_1, >= 0 and <= 255, else >= -32768 and <=
389 32767), but <0 or (if start_at_1) <1, calculate new ID: lowest unused ID
390 >=0 or (if start_at_1) >= 1, and <= 255. None is always returned when no
391 new object is created, otherwise the new object's ID.
393 min = 0 if start_at_1 else -32768
394 max = 255 if start_at_1 else 32767
396 id = integer_test(id, min, max)
398 if id in world_db[category]:
403 if (start_at_1 and 0 == id) \
404 or ((not start_at_1) and (id < 0 or id > 255)):
408 if id not in world_db[category]:
412 "No unused ID available to add to ID list.")
420 """Send PONG line to server output file."""
421 strong_write(io_db["file_out"], "PONG\n")
425 """Abort server process."""
426 raise SystemExit("received QUIT command")
429 def command_thingshere(y, x):
431 print("Ignoring not-yet implemented THINGS_HERE command.")
434 def command_seedmap(seed_string):
435 """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
436 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
440 def command_makeworld(seed_string):
442 setter(None, "SEED_RANDOMNESS", 0, 4294967295)(seed_string)
443 player_will_be_generated = False
444 playertype = world_db["PLAYER_TYPE"]
445 for ThingType in world_db["ThingTypes"]:
446 if playertype == ThingType:
447 if 0 < world_db["ThingTypes"][ThingType]["TT_START_NUMBER"]:
448 player_will_be_generated = True
450 if not player_will_be_generated:
451 print("Ignoring beyond SEED_MAP: " +
452 "No player type with start number >0 defined.")
455 for ThingAction in world_db["ThingActions"]:
456 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
459 print("Ignoring beyond SEED_MAP: " +
460 "No thing action with name 'wait' defined.")
462 setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
463 world_db["Things"] = {}
465 world_db["WORLD_ACTIVE"] = 1
467 for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
468 world_db["Things"][id_setter(-1, "Things")] = {
469 "T_LIFEPOINTS": world_db["ThingTypes"][playertype]["TT_LIFEPOINTS"],
470 "T_TYPE": playertype,
471 "T_POSY": 0, # randomize safely
472 "T_POSX": 0, # randomize safely
481 "T_MEMDEPTHMAP": False
484 # TODO: Generate things (player first, with updated memory)
485 strong_write(io_db["file_out"], "NEW_WORLD\n")
488 def command_maplength(maplength_string):
489 """Redefine map length. Invalidate map, therefore lose all things on it."""
491 world_db["Things"] = {}
492 setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
495 def command_worldactive(worldactive_string):
496 """Toggle world_db["WORLD_ACTIVE"] if possible.
498 An active world can always be set inactive. An inactive world can only be
499 set active with a "wait" ThingAction, and a player Thing (of ID 0). On
500 activation, rebuild all Things' FOVs and map memories.
502 # In original version, map existence was also tested (unnecessarily?).
503 val = integer_test(worldactive_string, 0, 1)
505 if 0 != world_db["WORLD_ACTIVE"]:
509 print("World already active.")
510 elif 0 == world_db["WORLD_ACTIVE"]:
512 for ThingAction in world_db["ThingActions"]:
513 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
516 player_exists = False
517 for Thing in world_db["Things"]:
521 if wait_exists and player_exists:
522 # TODO: rebuild all things' FOVs, map memories
523 world_db["WORLD_ACTIVE"] = 1
526 def test_for_id_maker(object, category):
527 """Return decorator testing for object having "id" attribute."""
530 if hasattr(object, "id"):
533 print("Ignoring: No " + category +
534 " defined to manipulate yet.")
539 def command_tid(id_string):
540 """Set ID of Thing to manipulate. ID unused? Create new one.
542 Default new Thing's type to the first available ThingType, others: zero.
544 id = id_setter(id_string, "Things", command_tid)
546 if world_db["ThingTypes"] == {}:
547 print("Ignoring: No ThingType to settle new Thing in.")
549 world_db["Things"][id] = {
555 "T_TYPE": list(world_db["ThingTypes"].keys())[0],
562 "T_MEMDEPTHMAP": False
566 test_Thing_id = test_for_id_maker(command_tid, "Thing")
570 def command_tcommand(str_int):
571 """Set T_COMMAND of selected Thing."""
572 val = integer_test(str_int, 0, 255)
574 if 0 == val or val in world_db["ThingActions"]:
575 world_db["Things"][command_tid.id]["T_COMMAND"] = val
577 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
581 def command_ttype(str_int):
582 """Set T_TYPE of selected Thing."""
583 val = integer_test(str_int, 0, 255)
585 if val in world_db["ThingTypes"]:
586 world_db["Things"][command_tid.id]["T_TYPE"] = val
588 print("Ignoring: ThingType ID belongs to no known ThingType.")
592 def command_tcarries(str_int):
593 """Append int(str_int) to T_CARRIES of selected Thing.
595 The ID int(str_int) must not be of the selected Thing, and must belong to a
596 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
598 val = integer_test(str_int, 0, 255)
600 if val == command_tid.id:
601 print("Ignoring: Thing cannot carry itself.")
602 elif val in world_db["Things"] \
603 and not world_db["Things"][val]["carried"]:
604 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
605 world_db["Things"][val]["carried"] = True
607 print("Ignoring: Thing not available for carrying.")
608 # Note that the whole carrying structure is different from the C version:
609 # Carried-ness is marked by a "carried" flag, not by Things containing
614 def command_tmemthing(str_t, str_y, str_x):
615 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
617 The type must fit to an existing ThingType, and the position into the map.
619 type = integer_test(str_t, 0, 255)
620 posy = integer_test(str_y, 0, 255)
621 posx = integer_test(str_x, 0, 255)
622 if None != type and None != posy and None != posx:
623 if type not in world_db["ThingTypes"] \
624 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
625 print("Ignoring: Illegal value for thing type or position.")
627 memthing = (type, posy, posx)
628 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
631 def setter_map(maptype):
632 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
634 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
637 def helper(str_int, mapline):
638 val = integer_test(str_int, 0, 255)
640 if val >= world_db["MAP_LENGTH"]:
641 print("Illegal value for map line number.")
642 elif len(mapline) != world_db["MAP_LENGTH"]:
643 print("Map line length is unequal map width.")
645 length = world_db["MAP_LENGTH"]
647 if not world_db["Things"][command_tid.id][maptype]:
648 rmap = bytearray(b' ' * (length ** 2))
650 rmap = world_db["Things"][command_tid.id][maptype]
651 rmap[val * length:(val * length) + length] = mapline.encode()
652 world_db["Things"][command_tid.id][maptype] = rmap
656 def setter_tpos(axis):
657 """Generate setter for T_POSX or T_POSY of selected Thing."""
660 val = integer_test(str_int, 0, 255)
662 if val < world_db["MAP_LENGTH"]:
663 world_db["Things"][command_tid.id]["T_POS" + axis] = val
664 # TODO: Delete Thing's FOV, and rebuild it if world is active.
666 print("Ignoring: Position is outside of map.")
670 def command_ttid(id_string):
671 """Set ID of ThingType to manipulate. ID unused? Create new one.
673 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
675 id = id_setter(id_string, "ThingTypes", command_ttid)
677 world_db["ThingTypes"][id] = {
682 "TT_START_NUMBER": 0,
688 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
692 def command_ttname(name):
693 """Set TT_NAME of selected ThingType."""
694 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
698 def command_ttsymbol(char):
699 """Set TT_SYMBOL of selected ThingType. """
701 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
703 print("Ignoring: Argument must be single character.")
707 def command_ttcorpseid(str_int):
708 """Set TT_CORPSE_ID of selected ThingType."""
709 val = integer_test(str_int, 0, 255)
711 if val in world_db["ThingTypes"]:
712 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
714 print("Ignoring: Corpse ID belongs to no known ThignType.")
717 def command_taid(id_string):
718 """Set ID of ThingAction to manipulate. ID unused? Create new one.
720 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
722 id = id_setter(id_string, "ThingActions", command_taid, True)
724 world_db["ThingActions"][id] = {
730 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
734 def command_taname(name):
735 """Set TA_NAME of selected ThingAction.
737 The name must match a valid thing action function. If after the name
738 setting no ThingAction with name "wait" remains, call set_world_inactive().
740 if name == "wait" or name == "move" or name == "use" or name == "drop" \
741 or name == "pick_up":
742 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
743 if 1 == world_db["WORLD_ACTIVE"]:
745 for id in world_db["ThingActions"]:
746 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
752 print("Ignoring: Invalid action name.")
753 # In contrast to the original,naming won't map a function to a ThingAction.
756 """Commands database.
758 Map command start tokens to ([0]) number of expected command arguments, ([1])
759 the command's meta-ness (i.e. is it to be written to the record file, is it to
760 be ignored in replay mode if read from server input file), and ([2]) a function
764 "QUIT": (0, True, command_quit),
765 "PING": (0, True, command_ping),
766 "THINGS_HERE": (2, True, command_thingshere),
767 "MAKE_WORLD": (1, False, command_makeworld),
768 "SEED_MAP": (1, False, command_seedmap),
769 "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS",
771 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
772 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
773 "MAP_LENGTH": (1, False, command_maplength),
774 "WORLD_ACTIVE": (1, False, command_worldactive),
775 "TA_ID": (1, False, command_taid),
776 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
777 "TA_NAME": (1, False, command_taname),
778 "TT_ID": (1, False, command_ttid),
779 "TT_NAME": (1, False, command_ttname),
780 "TT_SYMBOL": (1, False, command_ttsymbol),
781 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
782 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
784 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
786 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
788 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
789 "T_ID": (1, False, command_tid),
790 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
791 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
792 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
793 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
794 "T_COMMAND": (1, False, command_tcommand),
795 "T_TYPE": (1, False, command_ttype),
796 "T_CARRIES": (1, False, command_tcarries),
797 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
798 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
799 "T_MEMTHING": (3, False, command_tmemthing),
800 "T_POSY": (1, False, setter_tpos("Y")),
801 "T_POSX": (1, False, setter_tpos("X")),
805 """World state database. With sane default values."""
809 "SEED_RANDOMNESS": 0,
819 """File IO database."""
822 "path_record": "record",
823 "path_worldconf": "confserver/world",
824 "path_server": "server/",
825 "path_in": "server/in",
826 "path_out": "server/out",
827 "path_worldstate": "server/worldstate",
828 "tmp_suffix": "_tmp",
829 "kicked_by_rival": False,
830 "worldstate_updateable": False
835 opts = parse_command_line_arguments()
837 # print("DUMMY: Run game.")
838 if None != opts.replay:
842 except SystemExit as exit:
843 print("ABORTING: " + exit.args[0])
845 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
849 # print("DUMMY: (Clean up C heap.)")