commands_db[tokens[0]][2](*tokens[1:])
if do_record:
io_db["record_chunk"] += command + "\n"
- if time.time() > io_db["save_wait"] + 15:
+ if time.time() > io_db["save_wait"] + 300:
atomic_write(io_db["path_record"], io_db["record_chunk"],
do_append=True)
if world_db["WORLD_ACTIVE"]:
altar_placed = True # #
+def eat_vs_hunger_threshold(thingtype):
+ """Return satiation cost of eating for type. Good food for it must be >."""
+ hunger_unit = hunger_per_turn(thingtype)
+ actiontype = [id for id in world_db["ThingActions"]
+ if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
+ return world_db["ThingActions"][actiontype]["TA_EFFORT"] * hunger_unit
+
+
def update_map_memory(t, age_map=True):
"""Update t's T_MEMMAP with what's in its FOV now,age its T_MEMMEPTHMAP."""
fovmap = c_pointer_to_bytearray(t["fovmap"])
libpr.age_some_memdepthmap_on_nonfov_cells(memdepthmap, fovmap)
+ def update_mem_and_memdepthmap_via_fovmap():
+ # OUTSOURCED FOR PERFORMANCE REASONS TO libplomrogue.so:
+ # for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
+ # if ord_v == t["fovmap"][pos]]:
+ # t["T_MEMDEPTHMAP"][pos] = ord_0
+ # t["T_MEMMAP"][pos] = world_db["MAP"][pos]
+ memdepthmap = c_pointer_to_bytearray(t["T_MEMDEPTHMAP"])
+ memmap = c_pointer_to_bytearray(t["T_MEMMAP"])
+ fovmap = c_pointer_to_bytearray(t["fovmap"])
+ map = c_pointer_to_bytearray(world_db["MAP"])
+ libpr.update_mem_and_memdepthmap_via_fovmap(map, fovmap, memdepthmap,
+ memmap)
+
if not t["T_MEMMAP"]:
t["T_MEMMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
if not t["T_MEMDEPTHMAP"]:
t["T_MEMDEPTHMAP"] = bytearray(b' ' * (world_db["MAP_LENGTH"] ** 2))
- ord_v = ord("v")
- ord_0 = ord("0")
- ord_space = ord(" ")
- for pos in [pos for pos in range(world_db["MAP_LENGTH"] ** 2)
- if ord_v == t["fovmap"][pos]]:
- t["T_MEMDEPTHMAP"][pos] = ord_0
- t["T_MEMMAP"][pos] = world_db["MAP"][pos]
+ update_mem_and_memdepthmap_via_fovmap()
if age_map:
age_some_memdepthmap_on_nonfov_cells()
+ ord_v = ord("v")
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 ord_v == t["fovmap"][(y * world_db["MAP_LENGTH"]) + x]:
- t["T_MEMTHING"].append((type, y, x))
+ maplength = world_db["MAP_LENGTH"]
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"]) # #
+ [t["T_MEMTHING"].append((world_db["Things"][id]["T_TYPE"],
+ world_db["Things"][id]["T_POSY"],
+ world_db["Things"][id]["T_POSX"]))
+ for id in world_db["Things"]
+ if not world_db["Things"][id]["carried"]
+ if not world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
+ ["TT_LIFEPOINTS"]
+ if (t == world_db["Things"][0] or
+ (world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
+ ["TT_TOOL"] == "food"
+ and
+ world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
+ ["TT_TOOLPOWER"] > eat_cost
+ )
+ )
+ if ord_v == t["fovmap"][(world_db["Things"][id]["T_POSY"] * maplength)
+ + world_db["Things"][id]["T_POSX"]]]
def set_world_inactive():
Define topmostness by how low the thing's type ID is.
"""
# 7DRL: Non-player picking up player-dropped consumable -> GOD_FAVOR gain.
- # 7DRL: Only player picks up non-food.
+ # 7DRL: Non-players pick up nothing but food of good value to them.
used_slots = len(t["T_CARRIES"]) # #
if used_slots < world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]: # #
ids = [id for id in world_db["Things"] if world_db["Things"][id] != t
if world_db["Things"][id]["T_POSX"] == t["T_POSX"]]
if len(ids):
lowest_tid = -1
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"]) # #
for iid in ids:
tid = world_db["Things"][iid]["T_TYPE"]
if lowest_tid == -1 or tid < lowest_tid:
if (t != world_db["Things"][0] and # #
- world_db["ThingTypes"][tid]["TT_TOOL"] != "food"):
- continue
+ (world_db["ThingTypes"][tid]["TT_TOOL"] != "food" # #
+ or (world_db["ThingTypes"][tid]["TT_TOOLPOWER"] # #
+ <= eat_cost))): # #
+ continue # #
id = iid
lowest_tid = tid
world_db["Things"][id]["carried"] = True
The path-wise nearest target is chosen, via the shortest available path.
Target must not be t. On succcess, return positive value, else False.
Filters:
- "a": Thing in FOV is below a certain distance, animate, but of ThingType
- that is not t's, and starts out weaker than t is; build path as
- avoiding things of t's ThingType
- "f": neighbor cell (not inhabited by any animate Thing) further away from
- animate Thing not further than x steps away and in FOV and of a
- ThingType that is not t's, and starts out stronger or as strong as t
- is currently; or (cornered), if no such flight cell, but Thing of
- above criteria is too near,1 a cell closer to it, or, if less near,
- just wait
- "c": Thing in memorized map is consumable
+ "a": Thing in FOV is animate, but of ThingType, starts out weaker than t
+ is, and its corpse would be healthy food for t
+ "f": move away from an enemy – any visible actor whose thing type has more
+ TT_LIFEPOINTS than t LIFEPOINTS, and might find t's corpse healthy
+ food – if it is closer than n steps, where n will shrink as t's hunger
+ grows; if enemy is too close, move towards (attack) the enemy instead;
+ if no fleeing is possible, nor attacking useful, wait; don't tread on
+ non-enemies for fleeing
+ "c": Thing in memorized map is consumable of sufficient nutrition for t
"s": memory map cell with greatest-reachable degree of unexploredness
"""
raise RuntimeError("No score map allocated for "
"zero_score_map_where_char_on_memdepthmap().")
+ def set_map_score_at_thingpos(id, score):
+ pos = world_db["Things"][id]["T_POSY"] * world_db["MAP_LENGTH"] \
+ + world_db["Things"][id]["T_POSX"]
+ set_map_score(pos, score)
+
def set_map_score(pos, score):
test = libpr.set_map_score(pos, score)
if test:
raise RuntimeError("No score map allocated for get_map_score().")
return result
+ def animate_in_fov(Thing, maplength): # maplength needed for optimization?
+ if not Thing["T_LIFEPOINTS"] or Thing["carried"] or Thing == t:
+ return False
+ pos = Thing["T_POSY"] * maplength + Thing["T_POSX"]
+ if 118 == t["fovmap"][pos]: # optimization: 118 = ord("v")
+ return True
+
+ def good_attack_target(v):
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
+ type = world_db["ThingTypes"][v["T_TYPE"]]
+ type_corpse = world_db["ThingTypes"][type["TT_CORPSE_ID"]]
+ if t["T_LIFEPOINTS"] > type["TT_LIFEPOINTS"] \
+ and type_corpse["TT_TOOL"] == "food" \
+ and type_corpse["TT_TOOLPOWER"] > eat_cost:
+ return True
+ return False
+
+ def good_flee_target(m):
+ own_corpse_id = world_db["ThingTypes"][t["T_TYPE"]]["TT_CORPSE_ID"]
+ corpse_type = world_db["ThingTypes"][own_corpse_id]
+ targetness = 0 if corpse_type["TT_TOOL"] != "food" \
+ else corpse_type["TT_TOOLPOWER"]
+ type = world_db["ThingTypes"][m["T_TYPE"]]
+ if t["T_LIFEPOINTS"] < type["TT_LIFEPOINTS"] \
+ and targetness > eat_vs_hunger_threshold(m["T_TYPE"]):
+ return True
+ return False
+
def seeing_thing():
- if t["fovmap"] and ("a" == filter or "f" == filter):
+ maplength = world_db["MAP_LENGTH"]
+ if t["fovmap"] and "a" == filter:
for id in world_db["Things"]:
- Thing = world_db["Things"][id]
- if Thing != t and Thing["T_LIFEPOINTS"] and \
- t["T_TYPE"] != Thing["T_TYPE"] and \
- 'v' == chr(t["fovmap"][(Thing["T_POSY"]
- * world_db["MAP_LENGTH"])
- + Thing["T_POSX"]]):
- ThingType = world_db["ThingTypes"][Thing["T_TYPE"]]
- if ("f" == filter and ThingType["TT_LIFEPOINTS"] >=
- t["T_LIFEPOINTS"]) \
- or ("a" == filter and ThingType["TT_LIFEPOINTS"] <
- t["T_LIFEPOINTS"]):
+ if animate_in_fov(world_db["Things"][id], maplength):
+ if good_attack_target(world_db["Things"][id]):
+ return True
+ elif t["fovmap"] and "f" == filter:
+ for id in world_db["Things"]:
+ if animate_in_fov(world_db["Things"][id], maplength):
+ if good_flee_target(world_db["Things"][id]):
return True
elif t["T_MEMMAP"] and "c" == filter:
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
+ ord_blank = ord(" ")
for mt in t["T_MEMTHING"]:
- if ' ' != chr(t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
- + mt[2]]) \
- and world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food":
+ if ord_blank != t["T_MEMMAP"][(mt[1] * world_db["MAP_LENGTH"])
+ + mt[2]] and \
+ (t != world_db["Things"][0] or \
+ (world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"
+ and world_db["ThingTypes"][mt[0]]["TT_TOOLPOWER"]
+ > eat_cost)):
return True
return False
test = libpr.init_score_map()
if test:
raise RuntimeError("Malloc error in init_score_map().")
- ord_v = ord("v")
- ord_blank = ord(" ")
set_cells_passable_on_memmap_to_65534_on_scoremap()
+ maplength = world_db["MAP_LENGTH"]
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"]
- if t != Thing and Thing["T_LIFEPOINTS"] and \
- t["T_TYPE"] != Thing["T_TYPE"] and \
- ord_v == t["fovmap"][pos] and \
- t["T_LIFEPOINTS"] > \
- world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
- set_map_score(pos, 0)
- elif t["T_TYPE"] == Thing["T_TYPE"]:
- set_map_score(pos, 65535)
+ [set_map_score_at_thingpos(id, 0)
+ for id in world_db["Things"]
+ if animate_in_fov(world_db["Things"][id], maplength)
+ if good_attack_target(world_db["Things"][id])]
elif "f" == filter:
- for id in [id for id in world_db["Things"]
- if world_db["Things"][id]["T_LIFEPOINTS"]]:
- Thing = world_db["Things"][id]
- pos = Thing["T_POSY"] * world_db["MAP_LENGTH"] \
- + Thing["T_POSX"]
- if t["T_TYPE"] != Thing["T_TYPE"] and \
- ord_v == t["fovmap"][pos] and \
- t["T_LIFEPOINTS"] <= \
- world_db["ThingTypes"][Thing["T_TYPE"]]["TT_LIFEPOINTS"]:
- set_map_score(pos, 0)
+ [set_map_score_at_thingpos(id, 0)
+ for id in world_db["Things"]
+ if animate_in_fov(world_db["Things"][id], maplength)
+ if good_flee_target(world_db["Things"][id])]
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]]
- if world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food"]:
- set_map_score(mt[1] * world_db["MAP_LENGTH"] + mt[2], 0)
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
+ ord_blank = ord(" ")
+ [set_map_score(mt[1] * maplength + mt[2], 0)
+ for mt in t["T_MEMTHING"]
+ if ord_blank != t["T_MEMMAP"][mt[1] * maplength + mt[2]]
+ if t != world_db["Things"][0] or
+ (world_db["ThingTypes"][mt[0]]["TT_TOOL"] == "food" and
+ world_db["ThingTypes"][mt[0]]["TT_TOOLPOWER"] > eat_cost)]
elif "s" == filter:
zero_score_map_where_char_on_memdepthmap(mem_depth_c[0])
+ if "f" == filter:
+ [set_map_score_at_thingpos(id, 65535)
+ for id in world_db["Things"]
+ if animate_in_fov(world_db["Things"][id], maplength)
+ if get_map_score(world_db["Things"][id]["T_POSY"] * maplength
+ + world_db["Things"][id]["T_POSX"])]
+ elif "a" != filter:
+ [set_map_score_at_thingpos(id, 65535)
+ for id in world_db["Things"]
+ if animate_in_fov(world_db["Things"][id], maplength)]
def rand_target_dir(neighbors, cmp, dirs):
candidates = []
dirs = "edcxsw"
eye_pos = t["T_POSY"] * world_db["MAP_LENGTH"] + t["T_POSX"]
neighbors = get_neighbor_scores(dirs, eye_pos)
- if "f" == filter:
- inhabited = [world_db["Things"][id]["T_POSY"]
- * world_db["MAP_LENGTH"]
- + world_db["Things"][id]["T_POSX"]
- for id in world_db["Things"]
- if world_db["Things"][id]["T_LIFEPOINTS"]]
- 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()
- for pos in [pos for pos in inhabited if pos == pos_cmp]:
- neighbors[i] = 65535
- break
minmax_start = 0 if "f" == filter else 65535 - 1
minmax_neighbor = minmax_start
for i in range(len(dirs)):
if minmax_neighbor != minmax_start:
dir_to_target = rand_target_dir(neighbors, minmax_neighbor, dirs)
if "f" == filter:
+ distance = get_map_score(eye_pos)
+ fear_distance = world_db["MAP_LENGTH"]
+ if t["T_SATIATION"] < 0 and math.sqrt(-t["T_SATIATION"]) > 0:
+ fear_distance = fear_distance / math.sqrt(-t["T_SATIATION"])
+ attack_distance = 1
if not dir_to_target:
- if 1 == get_map_score(eye_pos):
- dir_to_target = rand_target_dir(neighbors, 0, dirs)
- elif 3 >= get_map_score(eye_pos):
+ if attack_distance >= distance:
+ dir_to_target = rand_target_dir(neighbors,
+ distance - 1, dirs)
+ elif fear_distance >= distance:
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if
world_db["ThingActions"][id]["TA_NAME"]
== "wait"][0]
return 1
- elif dir_to_target and 3 < get_map_score(eye_pos):
+ elif dir_to_target and fear_distance < distance:
dir_to_target = 0
- elif "a" == filter and 10 <= get_map_score(eye_pos):
- dir_to_target = 0
return dir_to_target
dir_to_target = False
def standing_on_food(t):
- """Return True/False whether t is standing on a consumable."""
+ """Return True/False whether t is standing on healthy consumable."""
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
for id in [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 world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
- ["TT_TOOL"] == "food"]:
+ ["TT_TOOL"] == "food"
+ if world_db["ThingTypes"][world_db["Things"][id]["T_TYPE"]]
+ ["TT_TOOLPOWER"] > eat_cost]:
return True
return False
cmp_food = -1
selection = -1
i = 0
- hunger_u = hunger_per_turn(t["T_TYPE"])
- type = [id for id in world_db["ThingActions"]
- if world_db["ThingActions"][id]["TA_NAME"] == "use"][0]
- consume_hungering = world_db["ThingActions"][type]["TA_EFFORT"] * hunger_u
+ eat_cost = eat_vs_hunger_threshold(t["T_TYPE"])
for id in t["T_CARRIES"]:
type = world_db["Things"][id]["T_TYPE"]
if world_db["ThingTypes"][type]["TT_TOOL"] == "food" \
and world_db["ThingTypes"][type]["TT_TOOLPOWER"]:
nutvalue = world_db["ThingTypes"][type]["TT_TOOLPOWER"]
- tmp_cmp = abs(t["T_SATIATION"] + nutvalue - consume_hungering)
+ tmp_cmp = abs(t["T_SATIATION"] + nutvalue - eat_cost)
if (cmp_food < 0 and tmp_cmp < abs(t["T_SATIATION"])) \
- or (cmp_food < 0 and 0 > t["T_SATIATION"] + nutvalue) \
or tmp_cmp < cmp_food:
cmp_food = tmp_cmp
selection = i
def ai(t):
- """Determine next command/argment for actor t via AI algorithms.
-
- AI will look for, and move towards, enemies (animate Things not of their
- own ThingType); if they see none, they will consume consumables in their
- inventory; if there are none, they will pick up what they stand on if they
- stand on consumables; if they stand on none, they will move towards the
- next consumable they see or remember on the map; if they see or remember
- none, they will explore parts of the map unseen since ever or for at least
- one turn; if there is nothing to explore, they will simply wait.
- """
+ """Determine next command/argment for actor t via AI algorithms."""
# 7DRL add: Don't pick up or search things when inventory is full.
+ if t == world_db["Things"][0]:
+ log("%AI------")
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
if world_db["ThingActions"][id]["TA_NAME"] == "wait"][0]
- if not get_dir_to_target(t, "f"):
- sel = get_inventory_slot_to_consume(t)
- if -1 != sel:
- t["T_COMMAND"] = [id for id in world_db["ThingActions"]
- if world_db["ThingActions"][id]["TA_NAME"]
- == "use"][0]
- t["T_ARGUMENT"] = sel
- elif standing_on_food(t) \
- and (len(t["T_CARRIES"]) < # #
- world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
+ if get_dir_to_target(t, "f"):
+ if t == world_db["Things"][0]:
+ log("%FLEE")
+ return
+ sel = get_inventory_slot_to_consume(t)
+ if -1 != sel:
+ if t == world_db["Things"][0]:
+ log("%EAT")
+ t["T_COMMAND"] = [id for id in world_db["ThingActions"]
+ if world_db["ThingActions"][id]["TA_NAME"]
+ == "use"][0]
+ t["T_ARGUMENT"] = sel
+ elif standing_on_food(t):
+ if t == world_db["Things"][0]:
+ log("%STANDINGON")
+ if (len(t["T_CARRIES"]) < # #
+ world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"]): # #
+ if t == world_db["Things"][0]:
+ log("%(pickingup)")
t["T_COMMAND"] = [id for id in world_db["ThingActions"]
- if world_db["ThingActions"][id]["TA_NAME"]
+ if world_db["ThingActions"][id]["TA_NAME"]
== "pick_up"][0]
- elif (not
- (len(t["T_CARRIES"]) < # #
- world_db["ThingTypes"][t["T_TYPE"]]["TT_STORAGE"] # #
- and get_dir_to_target(t, "c"))) and \
- (not get_dir_to_target(t, "a")):
- get_dir_to_target(t, "s")
+ else:
+ if t == world_db["Things"][0]:
+ log("%AIMING_FOR_FOOD")
+ going_to_known_food_spot = get_dir_to_target(t, "c")
+ if not going_to_known_food_spot:
+ if t == world_db["Things"][0]:
+ log("%AIMING_FOR_WALKING_FOOD")
+ aiming_for_walking_food = get_dir_to_target(t, "a")
+ if not aiming_for_walking_food:
+ if t == world_db["Things"][0]:
+ log("%SEARCHING")
+ get_dir_to_target(t, "s")
def turn_over():
"""Run game world and its inhabitants until new player input expected."""
+ # 7DRL: effort of move action is TA_EFFORT / sqrt(TT_LIFEPOINTS)
id = 0
whilebreaker = False
while world_db["Things"][0]["T_LIFEPOINTS"]:
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"]:
+ #if Thing["T_PROGRESS"] == ThingAction["TA_EFFORT"]:
+ effort = ThingAction["TA_EFFORT"] # #
+ if ThingAction["TA_NAME"] == "move": # #
+ type = Thing["T_TYPE"] # #
+ max_hp = (world_db["ThingTypes"][type] # #
+ ["TT_LIFEPOINTS"]) # #
+ effort = int(effort / math.sqrt(max_hp)) # #
+ if Thing["T_PROGRESS"] == effort: # #
eval("actor_" + ThingAction["TA_NAME"])(Thing)
Thing["T_COMMAND"] = 0
Thing["T_PROGRESS"] = 0
projects / plomrogue / blobdiff