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):
491 # TODO: remove map (is this necessary? no memory management trouble …)
492 world_db["Things"] = {}
493 setter(None, "MAP_LENGTH", 1, 256)(maplength_string)
496 def command_worldactive(worldactive_string):
498 val = integer_test(worldactive_string, 0, 1)
500 if 0 != world_db["WORLD_ACTIVE"]:
504 print("World already active.")
505 elif 0 == world_db["WORLD_ACTIVE"]:
507 for ThingAction in world_db["ThingActions"]:
508 if "wait" == world_db["ThingActions"][ThingAction]["TA_NAME"]:
511 player_exists = False
512 for Thing in world_db["Things"]:
516 map_exists = "MAP" in world_db
517 if wait_exists and player_exists and map_exists:
518 # TODO: rebuild all things' FOVs, map memories
519 world_db["WORLD_ACTIVE"] = 1
522 def test_for_id_maker(object, category):
523 """Return decorator testing for object having "id" attribute."""
526 if hasattr(object, "id"):
529 print("Ignoring: No " + category +
530 " defined to manipulate yet.")
535 def command_tid(id_string):
536 """Set ID of Thing to manipulate. ID unused? Create new one.
538 Default new Thing's type to the first available ThingType, others: zero.
540 id = id_setter(id_string, "Things", command_tid)
542 if world_db["ThingTypes"] == {}:
543 print("Ignoring: No ThingType to settle new Thing in.")
545 world_db["Things"][id] = {
551 "T_TYPE": list(world_db["ThingTypes"].keys())[0],
558 "T_MEMDEPTHMAP": False
562 test_Thing_id = test_for_id_maker(command_tid, "Thing")
566 def command_tcommand(str_int):
567 """Set T_COMMAND of selected Thing."""
568 val = integer_test(str_int, 0, 255)
570 if 0 == val or val in world_db["ThingActions"]:
571 world_db["Things"][command_tid.id]["T_COMMAND"] = val
573 print("Ignoring: ThingAction ID belongs to no known ThingAction.")
577 def command_ttype(str_int):
578 """Set T_TYPE of selected Thing."""
579 val = integer_test(str_int, 0, 255)
581 if val in world_db["ThingTypes"]:
582 world_db["Things"][command_tid.id]["T_TYPE"] = val
584 print("Ignoring: ThingType ID belongs to no known ThingType.")
588 def command_tcarries(str_int):
589 """Append int(str_int) to T_CARRIES of selected Thing.
591 The ID int(str_int) must not be of the selected Thing, and must belong to a
592 Thing with unset "carried" flag. Its "carried" flag will be set on owning.
594 val = integer_test(str_int, 0, 255)
596 if val == command_tid.id:
597 print("Ignoring: Thing cannot carry itself.")
598 elif val in world_db["Things"] \
599 and not world_db["Things"][val]["carried"]:
600 world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
601 world_db["Things"][val]["carried"] = True
603 print("Ignoring: Thing not available for carrying.")
604 # Note that the whole carrying structure is different from the C version:
605 # Carried-ness is marked by a "carried" flag, not by Things containing
610 def command_tmemthing(str_t, str_y, str_x):
611 """Add (int(str_t), int(str_y), int(str_x)) to selected Thing's T_MEMTHING.
613 The type must fit to an existing ThingType, and the position into the map.
615 type = integer_test(str_t, 0, 255)
616 posy = integer_test(str_y, 0, 255)
617 posx = integer_test(str_x, 0, 255)
618 if None != type and None != posy and None != posx:
619 if type not in world_db["ThingTypes"] \
620 or posy >= world_db["MAP_LENGTH"] or posx >= world_db["MAP_LENGTH"]:
621 print("Ignoring: Illegal value for thing type or position.")
623 memthing = (type, posy, posx)
624 world_db["Things"][command_tid.id]["T_MEMTHING"].append(memthing)
627 def setter_map(maptype):
628 """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
630 If Thing has no map of maptype yet, initialize it with ' ' bytes first.
633 def helper(str_int, mapline):
634 val = integer_test(str_int, 0, 255)
636 if val >= world_db["MAP_LENGTH"]:
637 print("Illegal value for map line number.")
638 elif len(mapline) != world_db["MAP_LENGTH"]:
639 print("Map line length is unequal map width.")
641 length = world_db["MAP_LENGTH"]
643 if not world_db["Things"][command_tid.id][maptype]:
644 rmap = bytearray(b' ' * (length ** 2))
646 rmap = world_db["Things"][command_tid.id][maptype]
647 rmap[val * length:(val * length) + length] = mapline.encode()
648 world_db["Things"][command_tid.id][maptype] = rmap
652 def setter_tpos(axis):
653 """Generate setter for T_POSX or T_POSY of selected Thing."""
656 val = integer_test(str_int, 0, 255)
658 if val < world_db["MAP_LENGTH"]:
659 world_db["Things"][command_tid.id]["T_POS" + axis] = val
660 # TODO: Delete Thing's FOV, and rebuild it if world is active.
662 print("Ignoring: Position is outside of map.")
666 def command_ttid(id_string):
667 """Set ID of ThingType to manipulate. ID unused? Create new one.
669 Default new ThingType's TT_SYMBOL to "?", TT_CORPSE_ID to self, others: 0.
671 id = id_setter(id_string, "ThingTypes", command_ttid)
673 world_db["ThingTypes"][id] = {
678 "TT_START_NUMBER": 0,
684 test_ThingType_id = test_for_id_maker(command_ttid, "ThingType")
688 def command_ttname(name):
689 """Set TT_NAME of selected ThingType."""
690 world_db["ThingTypes"][command_ttid.id]["TT_NAME"] = name
694 def command_ttsymbol(char):
695 """Set TT_SYMBOL of selected ThingType. """
697 world_db["ThingTypes"][command_ttid.id]["TT_SYMBOL"] = char
699 print("Ignoring: Argument must be single character.")
703 def command_ttcorpseid(str_int):
704 """Set TT_CORPSE_ID of selected ThingType."""
705 val = integer_test(str_int, 0, 255)
707 if val in world_db["ThingTypes"]:
708 world_db["ThingTypes"][command_ttid.id]["TT_CORPSE_ID"] = val
710 print("Ignoring: Corpse ID belongs to no known ThignType.")
713 def command_taid(id_string):
714 """Set ID of ThingAction to manipulate. ID unused? Create new one.
716 Default new ThingAction's TA_EFFORT to 1, its TA_NAME to "wait".
718 id = id_setter(id_string, "ThingActions", command_taid, True)
720 world_db["ThingActions"][id] = {
726 test_ThingAction_id = test_for_id_maker(command_taid, "ThingAction")
730 def command_taname(name):
731 """Set TA_NAME of selected ThingAction.
733 The name must match a valid thing action function. If after the name
734 setting no ThingAction with name "wait" remains, call set_world_inactive().
736 if name == "wait" or name == "move" or name == "use" or name == "drop" \
737 or name == "pick_up":
738 world_db["ThingActions"][command_taid.id]["TA_NAME"] = name
739 if 1 == world_db["WORLD_ACTIVE"]:
741 for id in world_db["ThingActions"]:
742 if "wait" == world_db["ThingActions"][id]["TA_NAME"]:
748 print("Ignoring: Invalid action name.")
749 # In contrast to the original,naming won't map a function to a ThingAction.
752 """Commands database.
754 Map command start tokens to ([0]) number of expected command arguments, ([1])
755 the command's meta-ness (i.e. is it to be written to the record file, is it to
756 be ignored in replay mode if read from server input file), and ([2]) a function
760 "QUIT": (0, True, command_quit),
761 "PING": (0, True, command_ping),
762 "THINGS_HERE": (2, True, command_thingshere),
763 "MAKE_WORLD": (1, False, command_makeworld),
764 "SEED_MAP": (1, False, command_seedmap),
765 "SEED_RANDOMNESS": (1, False, setter(None, "SEED_RANDOMNESS",
767 "TURN": (1, False, setter(None, "TURN", 0, 65535)),
768 "PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0, 255)),
769 "MAP_LENGTH": (1, False, command_maplength),
770 "WORLD_ACTIVE": (1, False, command_worldactive),
771 "TA_ID": (1, False, command_taid),
772 "TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
773 "TA_NAME": (1, False, command_taname),
774 "TT_ID": (1, False, command_ttid),
775 "TT_NAME": (1, False, command_ttname),
776 "TT_SYMBOL": (1, False, command_ttsymbol),
777 "TT_CORPSE_ID": (1, False, command_ttcorpseid),
778 "TT_CONSUMABLE": (1, False, setter("ThingType", "TT_CONSUMABLE",
780 "TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
782 "TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
784 "TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
785 "T_ID": (1, False, command_tid),
786 "T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
787 "T_PROGRESS": (1, False, setter("Thing", "T_PROGRESS", 0, 255)),
788 "T_LIFEPOINTS": (1, False, setter("Thing", "T_LIFEPOINTS", 0, 255)),
789 "T_SATIATION": (1, False, setter("Thing", "T_SATIATION", -32768, 32767)),
790 "T_COMMAND": (1, False, command_tcommand),
791 "T_TYPE": (1, False, command_ttype),
792 "T_CARRIES": (1, False, command_tcarries),
793 "T_MEMMAP": (2, False, setter_map("T_MEMMAP")),
794 "T_MEMDEPTHMAP": (2, False, setter_map("T_MEMDEPTHMAP")),
795 "T_MEMTHING": (3, False, command_tmemthing),
796 "T_POSY": (1, False, setter_tpos("Y")),
797 "T_POSX": (1, False, setter_tpos("X")),
801 """World state database. With sane default values."""
805 "SEED_RANDOMNESS": 0,
815 """File IO database."""
818 "path_record": "record",
819 "path_worldconf": "confserver/world",
820 "path_server": "server/",
821 "path_in": "server/in",
822 "path_out": "server/out",
823 "path_worldstate": "server/worldstate",
824 "tmp_suffix": "_tmp",
825 "kicked_by_rival": False,
826 "worldstate_updateable": False
831 opts = parse_command_line_arguments()
833 # print("DUMMY: Run game.")
834 if None != opts.replay:
838 except SystemExit as exit:
839 print("ABORTING: " + exit.args[0])
841 print("SOMETHING WENT WRONG IN UNEXPECTED WAYS")
845 # print("DUMMY: (Clean up C heap.)")