return libpr
+def c_pointer_to_bytearray(ba):
+ """Return C char * pointer to ba."""
+ type = ctypes.c_char * len(ba)
+ return type.from_buffer(ba)
+
+
def strong_write(file, string):
"""Apply write(string), then flush()."""
file.write(string)
path_tmp = path + tmp_suffix
msg = "Found file '" + path_tmp + "' that may be a leftover from an " \
"aborted previous attempt to write '" + path + "'. Aborting " \
- "until matter is resolved by removing it from its current path."
+ "until matter is resolved by removing it from its current path."
if os.access(path_tmp, os.F_OK):
raise SystemExit(msg)
io_db["teststring"] = str(os.getpid()) + " " + str(time.time())
is called (and io_db["record_chunk"] written) if 15 seconds have passed
since the last time it was called. The prefix string is inserted into the
server's input message between its beginning 'input ' and ':'. All activity
- is preceded by a server_test() call.
+ is preceded by a server_test() call. Commands that start with a lowercase
+ letter are ignored when world_db["WORLD_ACTIVE"] is False/0.
"""
server_test()
if io_db["verbose"]:
and len(tokens) == commands_db[tokens[0]][0] + 1:
if commands_db[tokens[0]][1]:
commands_db[tokens[0]][2](*tokens[1:])
+ elif tokens[0][0].islower() and not world_db["WORLD_ACTIVE"]:
+ print("Ignoring lowercase-starting commands when world inactive.")
elif replay:
print("Due to replay mode, reading command as 'go on in record'.")
line = io_db["file_record"].readline()
if time.time() > io_db["save_wait"] + 15:
atomic_write(io_db["path_record"], io_db["record_chunk"],
do_append=True)
- save_world()
+ if world_db["WORLD_ACTIVE"]:
+ save_world()
io_db["record_chunk"] = ""
io_db["save_wait"] = time.time()
io_db["worldstate_updateable"] = world_db["WORLD_ACTIVE"]
return '"' + string.replace('"', '\u005C"') + '"'
def mapsetter(key):
- def helper(id):
+ def helper(id=None):
string = ""
- if world_db["Things"][id][key]:
- map = world_db["Things"][id][key]
+ if key == "MAP" or world_db["Things"][id][key]:
+ map = world_db["MAP"] if key == "MAP" \
+ else world_db["Things"][id][key]
length = world_db["MAP_LENGTH"]
for i in range(length):
line = map[i * length:(i * length) + length].decode()
string = string + key + " " + str(i) + " " + quote(line) \
- + "\n"
+ + "\n"
return string
return helper
string = ""
for memthing in world_db["Things"][id]["T_MEMTHING"]:
string = string + "T_MEMTHING " + str(memthing[0]) + " " + \
- str(memthing[1]) + " " + str(memthing[2]) + "\n"
+ str(memthing[1]) + " " + str(memthing[2]) + "\n"
return string
def helper(category, id_string, special_keys={}):
string = ""
for key in sorted(world_db.keys()):
- if dict != type(world_db[key]) and key != "MAP" and \
- key != "WORLD_ACTIVE" and key != "SEED_MAP":
+ if (not isinstance(world_db[key], dict)) and key != "MAP" and \
+ key != "WORLD_ACTIVE":
string = string + key + " " + str(world_db[key]) + "\n"
- string = string + "SEED_MAP " + str(world_db["SEED_MAP"]) + "\n"
+ string = string + mapsetter("MAP")()
string = string + helper("ThingActions", "TA_ID")
string = string + helper("ThingTypes", "TT_ID", {"TT_CORPSE_ID": False})
for id in sorted(world_db["ThingTypes"].keys()):
string = string + "TT_ID " + str(id) + "\n" + "TT_CORPSE_ID " + \
- str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
+ str(world_db["ThingTypes"][id]["TT_CORPSE_ID"]) + "\n"
string = string + helper("Things", "T_ID",
{"T_CARRIES": False, "carried": False,
"T_MEMMAP": mapsetter("T_MEMMAP"),
for id in sorted(world_db["Things"].keys()):
if [] != world_db["Things"][id]["T_CARRIES"]:
string = string + "T_ID " + str(id) + "\n"
- for carried in sorted(world_db["Things"][id]["T_CARRIES"].keys()):
+ for carried in sorted(world_db["Things"][id]["T_CARRIES"]):
string = string + "T_CARRIES " + str(carried) + "\n"
string = string + "SEED_RANDOMNESS " + str(rand.seed) + "\n" + \
- "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
+ "WORLD_ACTIVE " + str(world_db["WORLD_ACTIVE"])
atomic_write(io_db["path_save"], string)
name = world_db["ThingTypes"][type_id]["TT_NAME"]
inventory = inventory + name + "\n"
string = str(world_db["TURN"]) + "\n" + \
- str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
- str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
- inventory + "%\n" + \
- str(world_db["Things"][0]["T_POSY"]) + "\n" + \
- str(world_db["Things"][0]["T_POSX"]) + "\n" + \
- str(world_db["MAP_LENGTH"]) + "\n"
+ str(world_db["Things"][0]["T_LIFEPOINTS"]) + "\n" + \
+ str(world_db["Things"][0]["T_SATIATION"]) + "\n" + \
+ inventory + "%\n" + \
+ str(world_db["Things"][0]["T_POSY"]) + "\n" + \
+ str(world_db["Things"][0]["T_POSX"]) + "\n" + \
+ str(world_db["MAP_LENGTH"]) + "\n"
length = world_db["MAP_LENGTH"]
fov = bytearray(b' ' * (length ** 2))
for pos in range(length ** 2):
obey(read_command(), "in file", do_record=True)
-def remake_map():
+def make_map():
"""(Re-)make island map.
Let "~" represent water, "." land, "X" trees: Build island shape randomly,
to land. The cycle ends when a land cell is due to be created at the map's
border. Then put some trees on the map (TODO: more precise algorithm desc).
"""
+
def is_neighbor(coordinates, type):
y = coordinates[0]
x = coordinates[1]
and type == chr(world_db["MAP"][pos + length - (not ind)])):
return True
return False
- store_seed = rand.seed
- rand.seed = world_db["SEED_MAP"]
+
world_db["MAP"] = bytearray(b'~' * (world_db["MAP_LENGTH"] ** 2))
length = world_db["MAP_LENGTH"]
add_half_width = (not (length % 2)) * int(length / 2)
x = rand.next() % length
pos = (y * length) + x
if "." == chr(world_db["MAP"][pos]) \
- and ((not single_allowed) or is_neighbor((y, x), "X")):
+ and ((not single_allowed) or is_neighbor((y, x), "X")):
world_db["MAP"][pos] = ord("X")
i_trees += 1
- rand.seed = store_seed
# This all-too-precise replica of the original C code misses iter_limit().
def update_map_memory(t, age_map=True):
"""Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
+
+ def age_some_memdepthmap_on_nonfov_cells():
+ # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
+ # ord_v = ord("v")
+ # ord_0 = ord("0")
+ # ord_9 = ord("9")
+ # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
+ # if not ord_v == t["fovmap"][pos]
+ # if ord_0 <= t["T_MEMDEPTHMAP"][pos]
+ # if ord_9 > t["T_MEMDEPTHMAP"][pos]
+ # if not rand.next() % (2 **
+ # (t["T_MEMDEPTHMAP"][pos] - 48))]:
+ # t["T_MEMDEPTHMAP"][pos] += 1
+ memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
+ fovmap = c_pointer_to_bytearray(t["fovmap"])
+ libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
+
if not t["T_MEMMAP"]:
t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
if not t["T_MEMDEPTHMAP"]:
if ord_space == t["T_MEMMAP"][pos]:
t["T_MEMMAP"][pos] = world_db["MAP"][pos]
if age_map:
- maptype = ctypes.c_char * len(t["T_MEMDEPTHMAP"])
- memdepthmap = maptype.from_buffer(t["T_MEMDEPTHMAP"])
- fovmap = maptype.from_buffer(t["fovmap"])
- libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
- for mt in [mt for mt in t["T_MEMTHING"]
- if "v" == chr(t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
- + mt[2]])]:
- t["T_MEMTHING"].remove(mt)
+ age_some_memdepthmap_on_nonfov_cells()
+ t["T_MEMTHING"] = [mt for mt in t["T_MEMTHING"]
+ if ord_v != t["fovmap"][(mt[1] * world_db["MAP_LENGTH"])
+ + mt[2]]]
for id in [id for id in world_db["Things"]
if not world_db["Things"][id]["carried"]]:
type = world_db["Things"][id]["T_TYPE"]
if not world_db["ThingTypes"][type]["TT_LIFEPOINTS"]:
y = world_db["Things"][id]["T_POSY"]
x = world_db["Things"][id]["T_POSX"]
- if "v" == chr(t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]):
+ if ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
t["T_MEMTHING"].append((type, y, x))
"""Return val_string if integer >= min & (if max set) <= max, else None."""
try:
val = int(val_string)
- if val < min or (max != None and val > max):
+ if val < min or (max is not None and val > max):
raise ValueError
return val
except ValueError:
msg = "Ignoring: Please use integer >= " + str(min)
- if max != None:
+ if max is not None:
msg += " and <= " + str(max)
msg += "."
print(msg)
def build_fov_map(t):
"""Build Thing's FOV map."""
t["fovmap"] = bytearray(b'v' * (world_db["MAP_LENGTH"] ** 2))
- maptype = ctypes.c_char * len(world_db["MAP"])
- test = libpr.build_fov_map(t["T_POSY"], t["T_POSX"],
- maptype.from_buffer(t["fovmap"]),
- maptype.from_buffer(world_db["MAP"]))
- if test:
+ fovmap = c_pointer_to_bytearray(t["fovmap"])
+ map = c_pointer_to_bytearray(world_db["MAP"])
+ if libpr.build_fov_map(t["T_POSY"], t["T_POSX"], fovmap, map):
raise RuntimeError("Malloc error in build_fov_Map().")
+def log_help():
+ """Send quick usage info to log."""
+ strong_write(io_db["file_out"], "LOG See README file for help.\n")
+
+
def decrement_lifepoints(t):
"""Decrement t's lifepoints by 1, and if to zero, corpse it.
If t is the player avatar, only blank its fovmap, so that the client may
still display memory data. On non-player things, erase fovmap and memory.
+ Dying actors drop all their things.
"""
t["T_LIFEPOINTS"] -= 1
if 0 == t["T_LIFEPOINTS"]:
+ for id in t["T_CARRIES"]:
+ t["T_CARRIES"].remove(id)
+ world_db["Things"][id]["T_POSY"] = t["T_POSY"]
+ world_db["Things"][id]["T_POSX"] = t["T_POSX"]
+ world_db["Things"][id]["carried"] = False
t["T_TYPE"] = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
if world_db["Things"][0] == t:
t["fovmap"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
strong_write(io_db["file_out"], "LOG You die.\n")
+ strong_write(io_db["file_out"],
+ "LOG See README on how to start over.\n")
else:
t["fovmap"] = False
t["T_MEMMAP"] = False
t["T_MEMDEPTHMAP"] = False
t["T_MEMTHING"] = []
- strong_write(io_db["file_out"], "LOG It dies.\n")
def mv_yx_in_dir_legal(dir, y, x):
if world_db["Things"][id]["T_POSX"] == move_result[2]]
if len(hitted):
hit_id = hitted[0]
- hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
- hitter = "You" if t == world_db["Things"][0] else hitter_name
- hitted_type = world_db["Things"][hit_id]["T_TYPE"]
- hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
- hitted = "you" if hit_id == 0 else hitted_name
- verb = " wound " if hitter == "You" else " wounds "
- strong_write(io_db["file_out"], "LOG " + hitter + verb + hitted +
- ".\n")
+ if t == world_db["Things"][0]:
+ hitted_type = world_db["Things"][hit_id]["T_TYPE"]
+ hitted_name = world_db["ThingTypes"][hitted_type]["TT_NAME"]
+ strong_write(io_db["file_out"], "LOG You wound "
+ + hitted_name + ".\n")
+ elif 0 == hit_id:
+ hitter_name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
+ strong_write(io_db["file_out"], "LOG " + hitter_name +
+ " wounds you.\n")
decrement_lifepoints(world_db["Things"][hit_id])
return
dir = [dir for dir in directions_db
def actor_pick_up(t):
"""Make t pick up (topmost?) Thing from ground into inventory."""
- # Topmostness is actually not defined so far. Picks Thing with highest ID.
+ # Topmostness is actually not defined so far. Picks most nutritious Thing.
ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
if not world_db["Things"][id]["carried"]
if world_db["Things"][id]["T_POSY"] == t["T_POSY"]
if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
if len(ids):
- highest_id = 0
+ highest_id = ids[0]
+ nutritious = 0
for id in ids:
- if id > highest_id:
+ type = world_db["Things"][id]["T_TYPE"]
+ if world_db["ThingTypes"][type]["TT_CONSUMABLE"] > nutritious:
+ nutritious = world_db["ThingTypes"][type]["TT_CONSUMABLE"]
highest_id = id
world_db["Things"][highest_id]["carried"] = True
t["T_CARRIES"].append(highest_id)
"LOG You try to use an object, but you own none.\n")
-def thingproliferation(t):
- """To chance of 1/TT_PROLIFERATE, create t offspring in neighbor cell.
+def thingproliferation(t, prol_map):
+ """To chance of 1/TT_PROLIFERATE, create t offspring in open neighbor cell.
- Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be
- passable and not be inhabited by a Thing of the same type, or, if Thing is
- animate, any other animate Thing. If there are several map cell candidates,
- one is selected randomly.
+ Naturally only works with TT_PROLIFERATE > 0. The neighbor cell must be be
+ marked '.' in prol_map. If there are several map cell candidates, one is
+ selected randomly.
"""
- def test_cell(t, y, x):
- if "." == chr(world_db["MAP"][(y * world_db["MAP_LENGTH"]) + x]):
- for id in [id for id in world_db["Things"]
- if y == world_db["Things"][id]["T_POSY"]
- if x == world_db["Things"][id]["T_POSX"]
- if (t["T_TYPE"] == world_db["Things"][id]["T_TYPE"])
- or (t["T_LIFEPOINTS"] and
- world_db["Things"][id]["T_LIFEPOINTS"])]:
- return False
- return True
- return False
prolscore = world_db["ThingTypes"][t["T_TYPE"]]["TT_PROLIFERATE"]
if prolscore and (1 == prolscore or 1 == (rand.next() % prolscore)):
candidates = []
for dir in [directions_db[key] for key in directions_db]:
mv_result = mv_yx_in_dir_legal(dir, t["T_POSY"], t["T_POSX"])
- if mv_result[0] and test_cell(t, mv_result[1], mv_result[2]):
+ if mv_result[0] and ord('.') == prol_map[mv_result[1]
+ * world_db["MAP_LENGTH"]
+ + mv_result[2]]:
candidates.append((mv_result[1], mv_result[2]))
if len(candidates):
i = rand.next() % len(candidates)
"""
if t["T_SATIATION"] > 0 \
and t["T_LIFEPOINTS"] < \
- world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
+ world_db["ThingTypes"][t["T_TYPE"]]["TT_LIFEPOINTS"] \
and 0 == (rand.next() % 31) \
and t["T_COMMAND"] == [id for id in world_db["ThingActions"]
if world_db["ThingActions"][id]["TA_NAME"] ==
- "wait"][0]:
+ "wait"][0]:
t["T_LIFEPOINTS"] += 1
t["T_SATIATION"] -= 32
if t == world_db["Things"][0]:
strong_write(io_db["file_out"], "LOG You heal.\n")
- else:
- name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
- strong_write(io_db["file_out"], "LOG " + name + "heals.\n")
def hunger(t):
if int(int(testbase / stomach) / ((rand.next() % stomach) + 1)):
if t == world_db["Things"][0]:
strong_write(io_db["file_out"], "LOG You suffer from hunger.\n")
- else:
- name = world_db["ThingTypes"][t["T_TYPE"]]["TT_NAME"]
- strong_write(io_db["file_out"], "LOG " + name +
- " suffers from hunger.\n")
decrement_lifepoints(t)
"""
def zero_score_map_where_char_on_memdepthmap(c):
- maptype = ctypes.c_char * len(t["T_MEMDEPTHMAP"])
- map = maptype.from_buffer(t["T_MEMDEPTHMAP"])
- test = libpr.zero_score_map_where_char_on_memdepthmap(c, map)
- if test:
+ # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
+ # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
+ # if t["T_MEMDEPTHMAP"][i] == mem_depth_c[0]]:
+ # set_map_score(i, 0)
+ map = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
+ if libpr.zero_score_map_where_char_on_memdepthmap(c, map):
raise RuntimeError("No score map allocated for "
"zero_score_map_where_char_on_memdepthmap().")
+ Thing["T_POSX"]]):
ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
- t["T_LIFEPOINTS"]) \
+ t["T_LIFEPOINTS"]) \
or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
- t["T_LIFEPOINTS"]):
+ t["T_LIFEPOINTS"]):
return True
elif t["T_MEMMAP"] and "c" == filter:
for mt in t["T_MEMTHING"]:
if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
- + mt[2]]) \
+ + mt[2]]) \
and world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]:
return True
return False
+ def set_cells_passable_on_memmap_to_65534_on_scoremap():
+ # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
+ # ord_dot = ord(".")
+ # memmap = t["T_MEMMAP"]
+ # for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
+ # if ord_dot == memmap[i]]:
+ # set_map_score(i, 65534) # i.e. 65535-1
+ map = c_pointer_to_bytearray(t["T_MEMMAP"])
+ if libpr.set_cells_passable_on_memmap_to_65534_on_scoremap(map):
+ raise RuntimeError("No score map allocated for set_cells_passable"
+ "_on_memmap_to_65534_on_scoremap().")
+
def init_score_map():
test = libpr.init_score_map()
if test:
raise RuntimeError("Malloc error in init_score_map().")
- ord_dot = ord(".")
ord_v = ord("v")
ord_blank = ord(" ")
- for i in [i for i in range(world_db["MAP_LENGTH"] ** 2)
- if ord_dot == t["T_MEMMAP"][i]]:
- set_map_score(i, 65535 - 1)
+ set_cells_passable_on_memmap_to_65534_on_scoremap()
if "a" == filter:
for id in world_db["Things"]:
Thing = world_db["Things"][id]
pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
- + Thing["T_POSX"]
+ + Thing["T_POSX"]
if t != Thing and Thing["T_LIFEPOINTS"] and \
t["T_TYPE"] != Thing["T_TYPE"] and \
ord_v == t["fovmap"][pos] and \
if world_db["Things"][id]["T_LIFEPOINTS"]]:
Thing = world_db["Things"][id]
pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
- + Thing["T_POSX"]
+ + Thing["T_POSX"]
if t["T_TYPE"] != Thing["T_TYPE"] and \
ord_v == t["fovmap"][pos] and \
t["T_LIFEPOINTS"] <= \
elif "c" == filter:
for mt in [mt for mt in t["T_MEMTHING"]
if ord_blank != t["T_MEMMAP"][mt[1]
- * world_db["MAP_LENGTH"]
- + mt[2]]
+ * world_db["MAP_LENGTH"]
+ + mt[2]]
if world_db["ThingTypes"][mt[0]]["TT_CONSUMABLE"]]:
set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
elif "s" == filter:
for i in range(len(dirs)):
mv_yx_in_dir_legal(dirs[i], t["T_POSY"], t["T_POSX"])
pos_cmp = libpr.result_y() * world_db["MAP_LENGTH"] \
- + libpr.result_x()
+ + libpr.result_x()
for pos in [pos for pos in inhabited if pos == pos_cmp]:
neighbors[i] = 65535
break
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if
world_db["ThingActions"][id]["TA_NAME"]
- == "wait"][0]
+ == "wait"][0]
return 1
elif dir_to_target and 3 < get_map_score(eye_pos):
dir_to_target = 0
run_i -= 1
init_score_map()
mem_depth_c = b'9' if b' ' == mem_depth_c \
- else bytes([mem_depth_c[0] - 1])
+ else bytes([mem_depth_c[0] - 1])
if libpr.dijkstra_map():
raise RuntimeError("No score map allocated for dijkstra_map().")
dir_to_target = get_dir_from_neighbors()
if dir_to_target and str == type(dir_to_target):
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if world_db["ThingActions"][id]["TA_NAME"]
- == "move"][0]
+ == "move"][0]
t["T_ARGUMENT"] = ord(dir_to_target)
return dir_to_target
if -1 != sel:
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if world_db["ThingActions"][id]["TA_NAME"]
- == "use"][0]
+ == "use"][0]
t["T_ARGUMENT"] = sel
elif standing_on_consumable(t):
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if world_db["ThingActions"][id]["TA_NAME"]
- == "pick_up"][0]
+ == "pick_up"][0]
elif (not get_dir_to_target(t, "c")) and \
(not get_dir_to_target(t, "a")):
get_dir_to_target(t, "s")
id = 0
whilebreaker = False
while world_db["Things"][0]["T_LIFEPOINTS"]:
+ proliferable_map = world_db["MAP"][:]
+ for id in [id for id in world_db["Things"]
+ if not world_db["Things"][id]["carried"]]:
+ y = world_db["Things"][id]["T_POSY"]
+ x = world_db["Things"][id]["T_POSX"]
+ proliferable_map[y * world_db["MAP_LENGTH"] + x] = ord('X')
for id in [id for id in world_db["Things"]]: # Only what's from start!
if not id in world_db["Things"] or \
world_db["Things"][id]["carried"]: # May have been consumed or
break
ai(Thing)
try_healing(Thing)
- Thing["T_PROGRESS"] += 1
- taid = [a for a in world_db["ThingActions"]
- if a == Thing["T_COMMAND"]][0]
- ThingAction = world_db["ThingActions"][taid]
- if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
- eval("actor_" + ThingAction["TA_NAME"])(Thing)
- Thing["T_COMMAND"] = 0
- Thing["T_PROGRESS"] = 0
hunger(Thing)
- thingproliferation(Thing)
+ if Thing["T_LIFEPOINTS"]:
+ Thing["T_PROGRESS"] += 1
+ taid = [a for a in world_db["ThingActions"]
+ if a == Thing["T_COMMAND"]][0]
+ ThingAction = world_db["ThingActions"][taid]
+ if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
+ eval("actor_" + ThingAction["TA_NAME"])(Thing)
+ Thing["T_COMMAND"] = 0
+ Thing["T_PROGRESS"] = 0
+ thingproliferation(Thing, proliferable_map)
if whilebreaker:
break
world_db["TURN"] += 1
id = id + 1
if id not in world_db[category]:
break
- return None
if id_store:
id_store.id = id
return id
def command_quit():
"""Abort server process."""
- save_world()
- atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
+ if None == opts.replay:
+ if world_db["WORLD_ACTIVE"]:
+ save_world()
+ atomic_write(io_db["path_record"], io_db["record_chunk"], do_append=True)
raise SystemExit("received QUIT command")
def set_command():
id = [x for x in world_db["ThingActions"]
- if world_db["ThingActions"][x]["TA_NAME"] == action][0]
+ if world_db["ThingActions"][x]["TA_NAME"] == action][0]
world_db["Things"][0]["T_COMMAND"] = id
turn_over()
rand.seed = val
-def command_seedmap(seed_string):
- """Set world_db["SEED_MAP"] to int(seed_string), then (re-)make map."""
- setter(None, "SEED_MAP", 0, 4294967295)(seed_string)
- remake_map()
-
-
def command_makeworld(seed_string):
"""(Re-)build game world, i.e. map, things, to a new turn 1 from seed.
- Seed rand with seed, fill it into world_db["SEED_MAP"]. Do more only with a
- "wait" ThingAction and world["PLAYER_TYPE"] matching ThingType of
- TT_START_NUMBER > 0. Then, world_db["Things"] emptied, call remake_map()
- and set world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
+ Seed rand with seed. Do more only with a "wait" ThingAction and
+ world["PLAYER_TYPE"] matching ThingType of TT_START_NUMBER > 0. Then,
+ world_db["Things"] emptied, call make_map() and set
+ world_db["WORLD_ACTIVE"], world_db["TURN"] to 1. Build new Things
according to ThingTypes' TT_START_NUMBERS, with Thing of ID 0 to ThingType
of ID = world["PLAYER_TYPE"]. Place Things randomly, and actors not on each
other. Init player's memory map. Write "NEW_WORLD" line to out file.
+ Call log_help().
"""
def free_pos():
if None == val:
return
rand.seed = val
- world_db["SEED_MAP"] = val
player_will_be_generated = False
playertype = world_db["PLAYER_TYPE"]
for ThingType in world_db["ThingTypes"]:
player_will_be_generated = True
break
if not player_will_be_generated:
- print("Ignoring beyond SEED_MAP: " +
- "No player type with start number >0 defined.")
+ print("Ignoring: No player type with start number >0 defined.")
return
wait_action = False
for ThingAction in world_db["ThingActions"]:
"No thing action with name 'wait' defined.")
return
world_db["Things"] = {}
- remake_map()
+ make_map()
world_db["WORLD_ACTIVE"] = 1
world_db["TURN"] = 1
for i in range(world_db["ThingTypes"][playertype]["TT_START_NUMBER"]):
id = id_setter(-1, "Things")
world_db["Things"][id] = new_Thing(playertype, free_pos())
+ if not world_db["Things"][0]["fovmap"]:
+ empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
+ world_db["Things"][0]["fovmap"] = empty_fovmap
update_map_memory(world_db["Things"][0])
for type in world_db["ThingTypes"]:
for i in range(world_db["ThingTypes"][type]["TT_START_NUMBER"]):
id = id_setter(-1, "Things")
world_db["Things"][id] = new_Thing(type, free_pos())
strong_write(io_db["file_out"], "NEW_WORLD\n")
+ log_help()
def command_maplength(maplength_string):
val = integer_test(maplength_string, 1, 256)
if None != val:
world_db["MAP_LENGTH"] = val
+ world_db["MAP"] = False
set_world_inactive()
world_db["Things"] = {}
libpr.set_maplength(val)
"""Toggle world_db["WORLD_ACTIVE"] if possible.
An active world can always be set inactive. An inactive world can only be
- set active with a "wait" ThingAction, and a player Thing (of ID 0). On
- activation, rebuild all Things' FOVs, and the player's map memory.
+ set active with a "wait" ThingAction, and a player Thing (of ID 0), and a
+ map. On activation, rebuild all Things' FOVs, and the player's map memory.
+ Also call log_help().
"""
- # In original version, map existence was also tested (unnecessarily?).
val = integer_test(worldactive_string, 0, 1)
- if val:
+ if None != val:
if 0 != world_db["WORLD_ACTIVE"]:
if 0 == val:
set_world_inactive()
if 0 == Thing:
player_exists = True
break
- if wait_exists and player_exists:
+ if wait_exists and player_exists and world_db["MAP"]:
for id in world_db["Things"]:
if world_db["Things"][id]["T_LIFEPOINTS"]:
build_fov_map(world_db["Things"][id])
if 0 == id:
update_map_memory(world_db["Things"][id], False)
+ if not world_db["Things"][0]["T_LIFEPOINTS"]:
+ empty_fovmap = bytearray(b" " * world_db["MAP_LENGTH"] ** 2)
+ world_db["Things"][0]["fovmap"] = empty_fovmap
world_db["WORLD_ACTIVE"] = 1
+ log_help()
+ else:
+ print("Ignoring: Not all conditions for world activation met.")
def test_for_id_maker(object, category):
if val == command_tid.id:
print("Ignoring: Thing cannot carry itself.")
elif val in world_db["Things"] \
- and not world_db["Things"][val]["carried"]:
+ and not world_db["Things"][val]["carried"]:
world_db["Things"][command_tid.id]["T_CARRIES"].append(val)
world_db["Things"][val]["carried"] = True
else:
def setter_map(maptype):
- """Set selected Thing's map of maptype's int(str_int)-th line to mapline.
+ """Set (world or Thing's) map of maptype's int(str_int)-th line to mapline.
- If Thing has no map of maptype yet, initialize it with ' ' bytes first.
+ If no map of maptype exists yet, initialize it with ' ' bytes first.
"""
- @test_Thing_id
- def helper(str_int, mapline):
+
+ def valid_map_line(str_int, mapline):
val = integer_test(str_int, 0, 255)
if None != val:
if val >= world_db["MAP_LENGTH"]:
elif len(mapline) != world_db["MAP_LENGTH"]:
print("Map line length is unequal map width.")
else:
- length = world_db["MAP_LENGTH"]
- map = None
- if not world_db["Things"][command_tid.id][maptype]:
- map = bytearray(b' ' * (length ** 2))
- else:
- map = world_db["Things"][command_tid.id][maptype]
- map[val * length:(val * length) + length] = mapline.encode()
+ return val
+ return None
+
+ def nonThingMap_helper(str_int, mapline):
+ val = valid_map_line(str_int, mapline)
+ if None != val:
+ length = world_db["MAP_LENGTH"]
+ if not world_db["MAP"]:
+ map = bytearray(b' ' * (length ** 2))
+ else:
+ map = world_db["MAP"]
+ map[val * length:(val * length) + length] = mapline.encode()
+ if not world_db["MAP"]:
+ world_db["MAP"] = map
+
+ @test_Thing_id
+ def ThingMap_helper(str_int, mapline):
+ val = valid_map_line(str_int, mapline)
+ if None != val:
+ length = world_db["MAP_LENGTH"]
+ if not world_db["Things"][command_tid.id][maptype]:
+ map = bytearray(b' ' * (length ** 2))
+ else:
+ map = world_db["Things"][command_tid.id][maptype]
+ map[val * length:(val * length) + length] = mapline.encode()
+ if not world_db["Things"][command_tid.id][maptype]:
world_db["Things"][command_tid.id][maptype] = map
- return helper
+
+ return nonThingMap_helper if maptype == "MAP" else ThingMap_helper
+
def setter_tpos(axis):
"PING": (0, True, command_ping),
"THINGS_HERE": (2, True, command_thingshere),
"MAKE_WORLD": (1, False, command_makeworld),
- "SEED_MAP": (1, False, command_seedmap),
"SEED_RANDOMNESS": (1, False, command_seedrandomness),
"TURN": (1, False, setter(None, "TURN", 0, 65535)),
"PLAYER_TYPE": (1, False, setter(None, "PLAYER_TYPE", 0)),
"MAP_LENGTH": (1, False, command_maplength),
"WORLD_ACTIVE": (1, False, command_worldactive),
+ "MAP": (2, False, setter_map("MAP")),
"TA_ID": (1, False, command_taid),
"TA_EFFORT": (1, False, setter("ThingAction", "TA_EFFORT", 0, 255)),
"TA_NAME": (1, False, command_taname),
"TT_START_NUMBER": (1, False, setter("ThingType", "TT_START_NUMBER",
0, 255)),
"TT_PROLIFERATE": (1, False, setter("ThingType", "TT_PROLIFERATE",
- 0, 255)),
+ 0, 65535)),
"TT_LIFEPOINTS": (1, False, setter("ThingType", "TT_LIFEPOINTS", 0, 255)),
"T_ID": (1, False, command_tid),
"T_ARGUMENT": (1, False, setter("Thing", "T_ARGUMENT", 0, 255)),
"use": (1, False, play_commander("use", True)),
"ai": (0, False, command_ai)
}
+# TODO: Unhandled cases: (Un-)killing animates (esp. player!) with T_LIFEPOINTS.
"""World state database. With sane default values. (Randomness is in rand.)"""
world_db = {
"TURN": 0,
"MAP_LENGTH": 64,
- "SEED_MAP": 0,
"PLAYER_TYPE": 0,
"WORLD_ACTIVE": 0,
+ "MAP": False,
"ThingActions": {},
"ThingTypes": {},
"Things": {}
projects / plomrogue / blobdiff