def manage_hands(life):
for item in [lfe.get_inventory_item(life, item) for item in lfe.get_held_items(life)]:
judgement.judge_item(life, item["uid"])
_known_item = brain.get_remembered_item(life, item["uid"])
if _known_item["score"]: # judgement.get_score_of_highest_scoring_item(life):
continue
_equip_action = {"action": "equipitem", "item": item["uid"]}
if len(lfe.find_action(life, matches=[_equip_action])):
return True
if lfe.can_wear_item(life, item["uid"]):
lfe.add_action(life, _equip_action, 401, delay=lfe.get_item_access_time(life, item["uid"]))
return True
_storage = lfe.can_put_item_in_storage(life, item["uid"])
if not "CAN_WEAR" in item["flags"] and _storage:
_store_action = {"action": "storeitem", "item": item["uid"], "container": _storage}
if len(lfe.find_action(life, matches=[_store_action])):
continue
lfe.add_action(life, _store_action, 401, delay=lfe.get_item_access_time(life, item["uid"]))
return True
return False
def explore_unknown_chunks(life):
if life['path']:
return True
_chunk_key = references.path_along_reference(life, 'roads')
if not _chunk_key:
return False
_walkable_area = chunks.get_walkable_areas(_chunk_key)
if not _walkable_area:
print 'no walkable area'
return False
_closest_pos = {'pos': None, 'distance': -1}
for pos in _walkable_area:
_distance = numbers.distance(life['pos'], pos)
if _distance <= 1:
_closest_pos['pos'] = pos
break
if not _closest_pos['pos'] or _distance < _closest_pos['distance']:
_closest_pos['pos'] = pos
_closest_pos['distance'] = _distance
lfe.clear_actions(life)
lfe.add_action(life, {'action': 'move', 'to': _closest_pos['pos']}, 200)
return True
def explore_unknown_chunks(life):
if life['path']:
return True
_chunk_key = references.path_along_reference(life, 'roads')
if not _chunk_key:
return False
_walkable_area = chunks.get_walkable_areas(_chunk_key)
if not _walkable_area:
print 'no walkable area'
return False
_closest_pos = {'pos': None, 'distance': -1}
for pos in _walkable_area:
_distance = bad_numbers.distance(life['pos'], pos)
if _distance <= 1:
_closest_pos['pos'] = pos
break
if not _closest_pos['pos'] or _distance<_closest_pos['distance']:
_closest_pos['pos'] = pos
_closest_pos['distance'] = _distance
lfe.clear_actions(life)
lfe.add_action(life,{'action': 'move','to': _closest_pos['pos']},200)
return True
def pick_up_item(life, item_uid):
_not_moved = travel_to_position(life, ITEMS[item_uid]["pos"])
if _not_moved:
lfe.add_action(
life, {"action": "pickupitem_npc", "item": item_uid}, 200, delay=lfe.get_item_access_time(life, item_uid)
)
def escape(life, targets):
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life['pos'])]
if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'escape'}]):
if lfe.ticker(life, 'escape_refresh', 4):
lfe.stop(life)
else:
return False
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target['last_seen_at'])
if not _zone in _zones:
_zones.append(_zone)
_avoid_positions.append(_target['last_seen_at'])
lfe.add_action(life, {'action': 'dijkstra_move',
'rolldown': False,
'zones': _zones,
'goals': _avoid_positions,
'reason': 'escape'},
100)
def find_target(life, target, distance=5, follow=False, call=True):
_target = brain.knows_alife_by_id(life, target)
_dist = numbers.distance(life['pos'], _target['last_seen_at'])
_can_see = sight.can_see_target(life, target)
if _can_see and _dist<=distance:
if follow:
return True
lfe.stop(life)
return True
if _target['escaped'] == 1:
search_for_target(life, target)
return False
if not _can_see and sight.can_see_position(life, _target['last_seen_at']) and _dist<distance:
if call:
if not _target['escaped']:
memory.create_question(life, target, 'GET_LOCATION')
speech.communicate(life, 'call', matches=[target])
_target['escaped'] = 1
return False
if not lfe.path_dest(life) == tuple(_target['last_seen_at'][:2]):
lfe.clear_actions(life)
lfe.add_action(life,
{'action': 'move','to': _target['last_seen_at'][:2]},
200)
return False
def explore_known_chunks(life):
# Our first order of business is to figure out exactly what we're looking for.
# There's a big difference between exploring the map looking for a purpose and
# exploring the map with a purpose. Both will use similar routines but I wager
# it'll actually be a lot harder to do it without there being some kind of goal
# to at least start us in the right direction.
# This function will kick in only if the ALife is idling, so looting is handled
# automatically.
# Note: Determining whether this fuction should run at all needs to be done inside
# the module itself.
_chunk_key = brain.retrieve_from_memory(life, "explore_chunk")
_chunk = maps.get_chunk(_chunk_key)
if life["path"] and chunks.position_is_in_chunk(lfe.path_dest(life), _chunk_key):
return True
if chunks.is_in_chunk(life, "%s,%s" % (_chunk["pos"][0], _chunk["pos"][1])):
life["known_chunks"][_chunk_key]["last_visited"] = WORLD_INFO["ticks"]
return False
if not _chunk["ground"]:
return False
_pos_in_chunk = random.choice(_chunk["ground"])
lfe.clear_actions(life)
lfe.add_action(life, {"action": "move", "to": _pos_in_chunk}, 200)
return True
def escape(life, targets):
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life['pos'])]
if lfe.find_action(life, [{
'action': 'dijkstra_move',
'reason': 'escape'
}]):
if lfe.ticker(life, 'escape_refresh', 4):
lfe.stop(life)
else:
return False
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target['last_seen_at'])
if not _zone in _zones:
_zones.append(_zone)
_avoid_positions.append(_target['last_seen_at'])
lfe.add_action(
life, {
'action': 'dijkstra_move',
'rolldown': False,
'zones': _zones,
'goals': _avoid_positions,
'reason': 'escape'
}, 100)
def collect_nearby_wanted_items(life,
only_visible=True,
matches={'type': 'gun'}):
_highest = {'item': None, 'score': -100000}
_nearby = sight.find_known_items(life,
matches=matches,
only_visible=only_visible)
for item in _nearby:
_item = brain.get_remembered_item(life, item)
_score = _item['score']
_score -= bad_numbers.distance(life['pos'], ITEMS[item]['pos'])
if not _highest['item'] or _score > _highest['score']:
_highest['score'] = _score
_highest['item'] = ITEMS[item]
if not _highest['item']:
return True
_empty_hand = lfe.get_open_hands(life)
if not _empty_hand:
print 'No open hands, managing....'
for item_uid in lfe.get_held_items(life):
_container = lfe.can_put_item_in_storage(life, item_uid)
lfe.add_action(life, {
'action': 'storeitem',
'item': item_uid,
'container': _container
},
200,
delay=lfe.get_item_access_time(life, item_uid))
return False
if life['pos'] == _highest['item']['pos']:
lfe.clear_actions(life)
for action in lfe.find_action(life,
matches=[{
'action': 'pickupholditem'
}]):
#print 'I was picking up something else...',_highest['item']['name']
return False
lfe.add_action(life, {
'action': 'pickupholditem',
'item': _highest['item']['uid'],
'hand': random.choice(_empty_hand)
},
200,
delay=lfe.get_item_access_time(life,
_highest['item']['uid']))
lfe.lock_item(life, _highest['item']['uid'])
else:
lfe.walk_to(life, _highest['item']['pos'])
return False
def pick_up_item(life, item_uid):
_not_moved = travel_to_position(life, ITEMS[item_uid]['pos'])
if _not_moved:
lfe.add_action(life,{'action': 'pickupitem_npc',
'item': item_uid},
200,
delay=lfe.get_item_access_time(life, item_uid))
def perform_recipe(life, item, recipe):
lfe.add_action(life, {
'action': 'craft',
'item_uid': item['uid'],
'recipe_id': item['craft'].index(recipe)
},
99999,
delay=recipe['time'])
def manage_inventory(life):
if manage_hands(life):
return False
for weapon_uid in combat.get_equipped_weapons(life):
if not combat.weapon_is_working(life, weapon_uid):
if combat.weapon_is_in_preferred_working_condition(life, weapon_uid):
if not len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
combat.reload_weapon(life, weapon_uid)
return True
_item_to_wear = {'score': 0, 'item_uid': None}
_item_to_equip = {'score': 0, 'item_uid': None}
for item in [lfe.get_inventory_item(life, item) for item in lfe.get_all_unequipped_items(life)]:
judgement.judge_item(life, item['uid'])
_known_item = brain.get_remembered_item(life, item['uid'])
if _known_item['score']:
if lfe.can_wear_item(life, item['uid']):
if _known_item['score'] > _item_to_wear['score']:
_item_to_wear['score'] = _known_item['score']
_item_to_wear['item_uid'] = item['uid']
else:
if rawparse.raw_has_section(life, 'items') and rawparse.raw_section_has_identifier(life, 'items', item['type']):
_action = lfe.execute_raw(life, 'items', item['type'])
if item['type'] == 'gun' and lfe.get_all_equipped_items(life, matches=[{'type': 'gun'}]):
continue
if _action == 'equip':
if _known_item['score'] > _item_to_equip['score']:
_item_to_equip['score'] = _known_item['score']
_item_to_equip['item_uid'] = item['uid']
_item = None
if _item_to_wear['score'] > _item_to_equip['score']:
_item = _item_to_wear['item_uid']
elif _item_to_equip['item_uid']:
_item = _item_to_equip['item_uid']
if _item:
_equip_action = {'action': 'equipitem', 'item': _item}
if len(lfe.find_action(life, matches=[_equip_action])):
return False
lfe.add_action(life,
_equip_action,
401,
delay=lfe.get_item_access_time(life, _item))
return False
return True
def pick_up_item(life, item_uid):
_not_moved = travel_to_position(life, ITEMS[item_uid]['pos'])
if _not_moved:
lfe.add_action(life, {
'action': 'pickupitem_npc',
'item': item_uid
},
200,
delay=lfe.get_item_access_time(life, item_uid))
def guard_camp(life):
_delay = random.randint(25, jobs.get_job_detail(life['job'], 'pause'))
if not life['path'] and not lfe.find_action(life, matches=[{'action': 'move'}]):
_chunk = WORLD_INFO['chunk_map'][references.find_least_populated_key_in_reference(life, CAMPS[life['camp']]['reference'])]
lfe.add_action(life,{'action': 'move',
'to': random.choice(_chunk['ground'])},
200,
delay=_delay)
return False
def load_feed(life, weapon_uid, feed_uid):
_load_action = {'action': 'reload',
'weapon': ITEMS[weapon_uid],
'ammo': ITEMS[feed_uid]}
if lfe.find_action(life, matches=[_load_action]):
return False
lfe.add_action(life, _load_action, 200, delay=0)
return True
def load_feed(life, weapon_uid, feed_uid):
_load_action = {'action': 'reload',
'weapon': ITEMS[weapon_uid],
'ammo': ITEMS[feed_uid]}
if lfe.find_action(life, matches=[_load_action]):
return False
lfe.add_action(life, _load_action, 200, delay=0)
return True
def manage_inventory(life):
if manage_hands(life):
return False
for weapon_uid in combat.get_equipped_weapons(life):
if not combat.weapon_is_working(life, weapon_uid):
if combat.weapon_is_in_preferred_working_condition(life, weapon_uid):
combat.reload_weapon(life, weapon_uid)
return True
_item_to_wear = {"score": 0, "item_uid": None}
_item_to_equip = {"score": 0, "item_uid": None}
for item in [lfe.get_inventory_item(life, item) for item in lfe.get_all_unequipped_items(life)]:
judgement.judge_item(life, item["uid"])
_known_item = brain.get_remembered_item(life, item["uid"])
if _known_item["score"]:
if lfe.can_wear_item(life, item["uid"]):
if _known_item["score"] > _item_to_wear["score"]:
_item_to_wear["score"] = _known_item["score"]
_item_to_wear["item_uid"] = item["uid"]
else:
if rawparse.raw_has_section(life, "items") and rawparse.raw_section_has_identifier(
life, "items", item["type"]
):
_action = lfe.execute_raw(life, "items", item["type"])
if _action == "equip":
if _known_item["score"] > _item_to_equip["score"]:
_item_to_equip["score"] = _known_item["score"]
_item_to_equip["item_uid"] = item["uid"]
_item = None
if _item_to_wear["score"] > _item_to_equip["score"]:
_item = _item_to_wear["item_uid"]
elif _item_to_equip["item_uid"]:
_item = _item_to_equip["item_uid"]
if _item:
_equip_action = {"action": "equipitem", "item": _item}
if len(lfe.find_action(life, matches=[_equip_action])):
return False
lfe.add_action(life, _equip_action, 401, delay=lfe.get_item_access_time(life, _item))
return True
return False
def collect_nearby_wanted_items(life, only_visible=True, matches={"type": "gun"}):
_highest = {"item": None, "score": -100000}
_nearby = sight.find_known_items(life, matches=matches, only_visible=only_visible)
for item in _nearby:
_item = brain.get_remembered_item(life, item)
_score = _item["score"]
_score -= numbers.distance(life["pos"], ITEMS[item]["pos"])
if not _highest["item"] or _score > _highest["score"]:
_highest["score"] = _score
_highest["item"] = ITEMS[item]
if not _highest["item"]:
return True
_empty_hand = lfe.get_open_hands(life)
if not _empty_hand:
print "No open hands, managing...."
for item_uid in lfe.get_held_items(life):
_container = lfe.can_put_item_in_storage(life, item_uid)
lfe.add_action(
life,
{"action": "storeitem", "item": item_uid, "container": _container},
200,
delay=lfe.get_item_access_time(life, item_uid),
)
return False
if life["pos"] == _highest["item"]["pos"]:
lfe.clear_actions(life)
for action in lfe.find_action(life, matches=[{"action": "pickupholditem"}]):
# print 'I was picking up something else...',_highest['item']['name']
return False
lfe.add_action(
life,
{"action": "pickupholditem", "item": _highest["item"]["uid"], "hand": random.choice(_empty_hand)},
200,
delay=lfe.get_item_access_time(life, _highest["item"]["uid"]),
)
lfe.lock_item(life, _highest["item"]["uid"])
else:
lfe.walk_to(life, _highest["item"]["pos"])
return False
def position_to_attack(life, target):
if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'positioning for attack'}]):
if not lfe.ticker(life, 'attack_position', 4):
return False
_target_positions, _zones = combat.get_target_positions_and_zones(life, [target])
_nearest_target_score = zones.dijkstra_map(life['pos'], _target_positions, _zones, return_score=True)
#TODO: Short or long-range weapon?
#if _nearest_target_score >= sight.get_vision(life)/2:
if not sight.can_see_position(life, brain.knows_alife_by_id(life, target)['last_seen_at'], block_check=True, strict=True) or sight.view_blocked_by_life(life, _target_positions[0], allow=[target]):
print life['name'], 'changing position for combat...', life['name'], LIFE[target]['name']
_avoid_positions = []
for life_id in life['seen']:
if life_id == target or life['id'] == life_id:
continue
if alife.judgement.can_trust(life, life_id):
_avoid_positions.append(lfe.path_dest(LIFE[life_id]))
else:
_avoid_positions.append(brain.knows_alife_by_id(life, life_id)['last_seen_at'])
_cover = _target_positions
_zones = []
for pos in _cover:
_zone = zones.get_zone_at_coords(pos)
if not _zone in _zones:
_zones.append(_zone)
if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': _cover[:], 'avoid_positions': _avoid_positions}]):
lfe.stop(life)
lfe.add_action(life, {'action': 'dijkstra_move',
'rolldown': True,
'goals': _cover[:],
'orig_goals': _cover[:],
'avoid_positions': _avoid_positions,
'reason': 'positioning for attack'},
999)
return False
else:
return False
elif life['path']:
lfe.stop(life)
return True
def manage_hands(life):
for item in [
lfe.get_inventory_item(life, item)
for item in lfe.get_held_items(life)
]:
judgement.judge_item(life, item['uid'])
_known_item = brain.get_remembered_item(life, item['uid'])
for weapon in combat.get_equipped_weapons(life):
if item['type'] == ITEMS[weapon]['feed'] and len(
item['rounds']) >= 5:
combat.load_feed(life, weapon, item['uid'])
return True
if _known_item[
'score']: #judgement.get_score_of_highest_scoring_item(life):
continue
_equip_action = {'action': 'equipitem', 'item': item['uid']}
if len(lfe.find_action(life, matches=[_equip_action])):
return True
if lfe.can_wear_item(life, item['uid']):
lfe.add_action(life,
_equip_action,
401,
delay=lfe.get_item_access_time(life, item['uid']))
return True
_storage = lfe.can_put_item_in_storage(life, item['uid'])
if not 'CAN_WEAR' in item['flags'] and _storage:
_store_action = {
'action': 'storeitem',
'item': item['uid'],
'container': _storage
}
if len(lfe.find_action(life, matches=[_store_action])):
continue
lfe.add_action(life,
_store_action,
401,
delay=lfe.get_item_access_time(life, item['uid']))
return True
return False
def travel_to_position(life, pos, stop_on_sight=False):
if stop_on_sight and sight.can_see_position(life, pos):
return True
if not numbers.distance(life['pos'], pos):
return True
_dest = lfe.path_dest(life)
if _dest and tuple(_dest[:2]) == tuple(pos[:2]):
return False
lfe.clear_actions(life)
lfe.add_action(life,{'action': 'move','to': (pos[0],pos[1])},200)
return False
def collect_nearby_wanted_items(life, only_visible=True, matches={'type': 'gun'}):
_highest = {'item': None,'score': -100000}
_nearby = sight.find_known_items(life, matches=matches, only_visible=only_visible)
for item in _nearby:
_item = brain.get_remembered_item(life, item)
_score = _item['score']
_score -= bad_numbers.distance(life['pos'], ITEMS[item]['pos'])
if not _highest['item'] or _score > _highest['score']:
_highest['score'] = _score
_highest['item'] = ITEMS[item]
if not _highest['item']:
return True
_empty_hand = lfe.get_open_hands(life)
if not _empty_hand:
print 'No open hands, managing....'
for item_uid in lfe.get_held_items(life):
_container = lfe.can_put_item_in_storage(life, item_uid)
lfe.add_action(life, {'action': 'storeitem',
'item': item_uid,
'container': _container},
200,
delay=lfe.get_item_access_time(life, item_uid))
return False
if life['pos'] == _highest['item']['pos']:
lfe.clear_actions(life)
for action in lfe.find_action(life, matches=[{'action': 'pickupholditem'}]):
#print 'I was picking up something else...',_highest['item']['name']
return False
lfe.add_action(life,{'action': 'pickupholditem',
'item': _highest['item']['uid'],
'hand': random.choice(_empty_hand)},
200,
delay=lfe.get_item_access_time(life, _highest['item']['uid']))
lfe.lock_item(life, _highest['item']['uid'])
else:
lfe.walk_to(life, _highest['item']['pos'])
return False
def _refill_feed(life, feed):
if not lfe.is_holding(life, feed['uid']) and not lfe.can_hold_item(life):
logging.warning('No hands free to load ammo!')
return False
if not lfe.get_held_items(life, matches=[{'id': feed['uid']}]) and lfe.item_is_stored(life, feed['uid']) and not lfe.find_action(life, matches=[{'action': 'removeandholditem'}]):
lfe.add_action(life,{'action': 'removeandholditem',
'item': feed['uid']},
200,
delay=0)
return False
#TODO: No check for ammo type.
_loading_rounds = len(lfe.find_action(life,matches=[{'action': 'refillammo'}]))
if _loading_rounds >= len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])):
#TODO: What?
if not _loading_rounds:
return True
return False
if len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
return False
_rounds = len(feed['rounds'])
if _rounds>=feed['maxrounds']:
print 'Full?'
return True
_ammo_count = len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
_ammo_count += len(feed['rounds'])
_rounds_to_load = numbers.clip(_ammo_count,0,feed['maxrounds'])
for ammo in lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])[:_rounds_to_load]:
lfe.add_action(life,{'action': 'refillammo',
'ammo': feed,
'round': ammo},
200,
delay=3)
_rounds += 1
return False
def guard_camp(life):
_delay = random.randint(25, jobs.get_job_detail(life['job'], 'pause'))
if not life['path'] and not lfe.find_action(life,
matches=[{
'action': 'move'
}]):
_chunk = WORLD_INFO['chunk_map'][
references.find_least_populated_key_in_reference(
life, CAMPS[life['camp']]['reference'])]
lfe.add_action(life, {
'action': 'move',
'to': random.choice(_chunk['ground'])
},
200,
delay=_delay)
return False
def _refill_feed(life, feed):
if not lfe.is_holding(life, feed['uid']) and not lfe.can_hold_item(life):
logging.warning('No hands free to load ammo!')
return False
if not lfe.get_held_items(life, matches=[{'id': feed['uid']}]) and lfe.item_is_stored(life, feed['uid']) and not lfe.find_action(life, matches=[{'action': 'removeandholditem'}]):
lfe.add_action(life,{'action': 'removeandholditem',
'item': feed['uid']},
200,
delay=0)
return False
#TODO: No check for ammo type.
_loading_rounds = len(lfe.find_action(life, matches=[{'action': 'refillammo'}]))
_bullets_in_inventory = len(lfe.get_all_inventory_items(life, matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
if _loading_rounds:# >= _bullets_in_inventory:
return False
if len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
return False
_rounds = len(feed['rounds'])
if _rounds>=feed['maxrounds'] or (not _bullets_in_inventory and _rounds):
print 'Full?'
return True
_ammo_count = len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
_ammo_count += len(feed['rounds'])
_rounds_to_load = numbers.clip(_ammo_count,0,feed['maxrounds'])
for ammo in lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])[:_rounds_to_load]:
lfe.add_action(life,{'action': 'refillammo',
'ammo': feed,
'round': ammo},
200,
delay=3)
_rounds += 1
return False
def _equip_weapon(life, weapon_uid, feed_uid):
_weapon = ITEMS[weapon_uid]
_feed = ITEMS[feed_uid]
#TODO: Need to refill ammo?
if not weapons.get_feed(_weapon):
#TODO: How much time should we spend loading rounds if we're in danger?
if _refill_feed(life, _feed):
load_feed(life, _weapon['uid'], _feed['uid'])
else:
print 'should be equippan?'
lfe.add_action(life,{'action': 'equipitem',
'item': weapon_uid},
300,
delay=0)
print 'Loaded!'
return True
return True
def manage_hands(life):
for item in [lfe.get_inventory_item(life, item) for item in lfe.get_held_items(life)]:
judgement.judge_item(life, item['uid'])
_known_item = brain.get_remembered_item(life, item['uid'])
for weapon in combat.get_equipped_weapons(life):
if item['type'] == ITEMS[weapon]['feed'] and len(item['rounds'])>=5:
combat.load_feed(life, weapon, item['uid'])
return True
if _known_item['score']:#judgement.get_score_of_highest_scoring_item(life):
continue
_equip_action = {'action': 'equipitem',
'item': item['uid']}
if len(lfe.find_action(life, matches=[_equip_action])):
return True
if lfe.can_wear_item(life, item['uid']):
lfe.add_action(life, _equip_action,
401,
delay=lfe.get_item_access_time(life, item['uid']))
return True
_storage = lfe.can_put_item_in_storage(life, item['uid'])
if not 'CAN_WEAR' in item['flags'] and _storage:
_store_action = {'action': 'storeitem',
'item': item['uid'],
'container': _storage}
if len(lfe.find_action(life, matches=[_store_action])):
continue
lfe.add_action(life,_store_action,
401,
delay=lfe.get_item_access_time(life, item['uid']))
return True
return False
def _equip_weapon(life, weapon_uid, feed_uid):
_weapon = ITEMS[weapon_uid]
_feed = ITEMS[feed_uid]
#TODO: Need to refill ammo?
if not weapons.get_feed(_weapon):
#TODO: How much time should we spend loading rounds if we're in danger?
if _refill_feed(life, _feed):
load_feed(life, _weapon['uid'], _feed['uid'])
else:
print 'should be equippan?'
lfe.add_action(life,{'action': 'equipitem',
'item': weapon_uid},
300,
delay=0)
print 'Loaded!'
return True
return True
def ranged_combat(life, targets):
_target = get_closest_target(life, targets)
if not _target:
for target_id in targets:
if brain.knows_alife_by_id(life, target_id)['escaped']:
continue
brain.knows_alife_by_id(life, target_id)['escaped'] = 1
logging.error('No target for ranged combat.')
return False
if not life['path'] or not numbers.distance(lfe.path_dest(life), _target['last_seen_at']) == 0:
movement.position_to_attack(life, _target['life']['id'])
if sight.can_see_position(life, _target['last_seen_at'], block_check=True, strict=True) and not sight.view_blocked_by_life(life, _target['last_seen_at'], allow=[_target['life']['id']]):
if sight.can_see_position(life, _target['life']['pos']):
if not len(lfe.find_action(life, matches=[{'action': 'shoot'}])):
for i in range(weapons.get_rounds_to_fire(weapons.get_weapon_to_fire(life))):
lfe.add_action(life,{'action': 'shoot',
'target': _target['last_seen_at'],
'target_id': _target['life']['id'],
'limb': 'chest'},
5000,
delay=int(round(life['recoil']-stats.get_recoil_recovery_rate(life))))
else:
lfe.memory(life,'lost sight of %s' % (' '.join(_target['life']['name'])), target=_target['life']['id'])
_target['escaped'] = 1
for send_to in judgement.get_trusted(life):
speech.communicate(life,
'target_missing',
target=_target['life']['id'],
matches=[send_to])
else:
print life['name'], 'waiting...'
return False
def explore_unknown_chunks(life):
if life["path"]:
return True
_chunk_key = references.path_along_reference(life, "roads")
if not _chunk_key:
_best_reference = references._find_best_unknown_reference(life, "roads")["reference"]
if not _best_reference:
return False
_chunk_key = references.find_nearest_key_in_reference(life, _best_reference, unknown=True, threshold=15)
if not _chunk_key:
return False
_walkable_area = chunks.get_walkable_areas(_chunk_key)
if not _walkable_area:
print "no walkable area"
return False
_closest_pos = {"pos": None, "distance": -1}
for pos in _walkable_area:
_distance = numbers.distance(life["pos"], pos)
if _distance <= 1:
_closest_pos["pos"] = pos
break
if not _closest_pos["pos"] or _distance < _closest_pos["distance"]:
_closest_pos["pos"] = pos
_closest_pos["distance"] = _distance
lfe.clear_actions(life)
lfe.add_action(life, {"action": "move", "to": _closest_pos["pos"]}, 200)
return True
def escape(life, targets):
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life["pos"])]
if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "escape"}]):
if lfe.ticker(life, "escape_refresh", 4):
lfe.stop(life)
else:
return False
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target["last_seen_at"])
if not _zone in _zones:
_zones.append(_zone)
_avoid_positions.append(_target["last_seen_at"])
lfe.add_action(
life,
{"action": "dijkstra_move", "rolldown": False, "zones": _zones, "goals": _avoid_positions, "reason": "escape"},
100,
)
def hide(life, targets):
_target_positions = []
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life["pos"])]
if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "escaping"}]):
if not lfe.ticker(life, "escaping", 6):
return False
# What can the targets see?
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target["last_seen_at"])
if not _zone in _zones:
_zones.append(_zone)
fov.fov(
_target["last_seen_at"],
sight.get_vision(_target["life"]),
callback=lambda pos: _avoid_positions.append(pos),
)
# What can we see?
_can_see_positions = []
fov.fov(life["pos"], sight.get_vision(life), callback=lambda pos: _can_see_positions.append(pos))
# If there are no visible targets, we could be running away from a position we were attacked from
_cover_exposed_at = brain.get_flag(life, "cover_exposed_at")
if _cover_exposed_at:
_avoid_exposed_cover_positions = set()
for pos in _cover_exposed_at[:]:
if tuple(pos[:2]) in _can_see_positions:
_cover_exposed_at.remove(pos)
continue
fov.fov(
pos,
int(round(sight.get_vision(life) * 0.25)),
callback=lambda pos: _avoid_exposed_cover_positions.add(pos),
)
for pos in _avoid_exposed_cover_positions:
if not pos in _avoid_positions:
_avoid_positions.append(pos)
else:
print "Something went wrong"
return False
# Overlay the two, finding positions we can see but the target can't
for pos in _can_see_positions[:]:
if pos in _avoid_positions:
_can_see_positions.remove(pos)
continue
# Get rid of positions that are too close
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
if numbers.distance(_target["last_seen_at"], pos) < 4:
_can_see_positions.remove(pos)
break
# Now scan for cover to prevent hiding in the open
for pos in _can_see_positions[:]:
if chunks.get_chunk(chunks.get_chunk_key_at(pos))["max_z"] == 2:
_can_see_positions.remove(pos)
if not _can_see_positions:
if life["pos"] in _cover_exposed_at:
_cover_exposed_at.remove(life["pos"])
return False
if lfe.find_action(life, [{"action": "dijkstra_move", "goals": _can_see_positions[:]}]):
return True
lfe.stop(life)
lfe.add_action(
life,
{
"action": "dijkstra_move",
"rolldown": True,
"zones": _zones,
"goals": _can_see_positions[:],
"reason": "escaping",
},
200,
)
def perform_recipe(life, item, recipe):
lfe.add_action(life, {'action': 'craft',
'item_uid': item['uid'],
'recipe_id': item['craft'].index(recipe)},
99999,
delay=recipe['time'])
def ranged_combat(life, targets):
_target = brain.knows_alife_by_id(life, get_closest_target(life, targets))
#if not _target:
# for target_id in targets:
# if brain.knows_alife_by_id(life, target_id)['escaped']:
# continue
#
# brain.knows_alife_by_id(life, target_id)['escaped'] = 1
#
# logging.error('No target for ranged combat.')
#
# return False
_engage_distance = get_engage_distance(life)
_path_dest = lfe.path_dest(life)
if not _path_dest:
_path_dest = life['pos'][:]
_target_distance = bad_numbers.distance(life['pos'], _target['last_seen_at'])
#Get us near the target
#if _target['last_seen_at']:
movement.position_to_attack(life, _target['life']['id'], _engage_distance)
if sight.can_see_position(life, _target['last_seen_at']):
if _target_distance <= _engage_distance:
if sight.can_see_position(life, _target['life']['pos']):
if not sight.view_blocked_by_life(life, _target['life']['pos'], allow=[_target['life']['id']]):
lfe.clear_actions(life)
if not len(lfe.find_action(life, matches=[{'action': 'shoot'}])) and _target['time_visible']>2:
for i in range(weapons.get_rounds_to_fire(weapons.get_weapon_to_fire(life))):
lfe.add_action(life, {'action': 'shoot',
'target': _target['last_seen_at'],
'target_id': _target['life']['id'],
'limb': 'chest'},
300,
delay=int(round(life['recoil']-stats.get_recoil_recovery_rate(life))))
else:
_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
_friendly_positions.append(life['pos'][:])
if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
lfe.add_action(life, {'action': 'dijkstra_move',
'rolldown': True,
'zones': _friendly_zones,
'goals': [_target['life']['pos'][:]],
'orig_goals': [_target['life']['pos'][:]],
'avoid_positions': _friendly_positions,
'reason': 'combat_position'},
100)
else:
lfe.memory(life,'lost sight of %s' % (' '.join(_target['life']['name'])), target=_target['life']['id'])
_target['escaped'] = 1
for send_to in judgement.get_trusted(life):
speech.communicate(life,
'target_missing',
target=_target['life']['id'],
matches=[send_to])
#else:
#print life['name']
#_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
#_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
#_friendly_positions.append(life['pos'][:])
#if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
# lfe.add_action(life, {'action': 'dijkstra_move',
# 'rolldown': True,
# 'zones': _friendly_zones,
# 'goals': [_target['life']['pos'][:]],
# 'orig_goals': [_target['life']['pos'][:]],
# 'avoid_positions': _friendly_positions,
# 'reason': 'combat_position'},
# 100)
#
# print '2'
else:
return False
def ranged_combat(life, targets):
_target = brain.knows_alife_by_id(life, get_closest_target(life, targets))
#if not _target:
# for target_id in targets:
# if brain.knows_alife_by_id(life, target_id)['escaped']:
# continue
#
# brain.knows_alife_by_id(life, target_id)['escaped'] = 1
#
# logging.error('No target for ranged combat.')
#
# return False
_engage_distance = get_engage_distance(life)
_path_dest = lfe.path_dest(life)
if not _path_dest:
_path_dest = life['pos'][:]
_target_distance = bad_numbers.distance(life['pos'],
_target['last_seen_at'])
#Get us near the target
#if _target['last_seen_at']:
movement.position_to_attack(life, _target['life']['id'], _engage_distance)
if sight.can_see_position(life, _target['last_seen_at']):
if _target_distance <= _engage_distance:
if sight.can_see_position(life, _target['life']['pos']):
if not sight.view_blocked_by_life(
life,
_target['life']['pos'],
allow=[_target['life']['id']]):
lfe.clear_actions(life)
if not len(
lfe.find_action(
life, matches=[{
'action': 'shoot'
}])) and _target['time_visible'] > 2:
for i in range(
weapons.get_rounds_to_fire(
weapons.get_weapon_to_fire(life))):
lfe.add_action(
life, {
'action': 'shoot',
'target': _target['last_seen_at'],
'target_id': _target['life']['id'],
'limb': 'chest'
},
300,
delay=int(
round(
life['recoil'] -
stats.get_recoil_recovery_rate(life))))
else:
_friendly_positions, _friendly_zones = get_target_positions_and_zones(
life, judgement.get_trusted(life))
_friendly_zones.append(
zones.get_zone_at_coords(life['pos']))
_friendly_positions.append(life['pos'][:])
if not lfe.find_action(
life, [{
'action': 'dijkstra_move',
'orig_goals': [_target['life']['pos'][:]],
'avoid_positions': _friendly_positions
}]):
lfe.add_action(
life, {
'action': 'dijkstra_move',
'rolldown': True,
'zones': _friendly_zones,
'goals': [_target['life']['pos'][:]],
'orig_goals': [_target['life']['pos'][:]],
'avoid_positions': _friendly_positions,
'reason': 'combat_position'
}, 100)
else:
lfe.memory(life,
'lost sight of %s' %
(' '.join(_target['life']['name'])),
target=_target['life']['id'])
_target['escaped'] = 1
for send_to in judgement.get_trusted(life):
speech.communicate(life,
'target_missing',
target=_target['life']['id'],
matches=[send_to])
#else:
#print life['name']
#_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
#_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
#_friendly_positions.append(life['pos'][:])
#if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
# lfe.add_action(life, {'action': 'dijkstra_move',
# 'rolldown': True,
# 'zones': _friendly_zones,
# 'goals': [_target['life']['pos'][:]],
# 'orig_goals': [_target['life']['pos'][:]],
# 'avoid_positions': _friendly_positions,
# 'reason': 'combat_position'},
# 100)
#
# print '2'
else:
return False
def hide(life, targets):
_target_positions = []
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life['pos'])]
if lfe.find_action(life, [{
'action': 'dijkstra_move',
'reason': 'escaping'
}]):
if not lfe.ticker(life, 'escaping', 6):
return False
#What can the targets see?
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target['last_seen_at'])
if not _zone in _zones:
_zones.append(_zone)
fov.fov(_target['last_seen_at'],
sight.get_vision(_target['life']),
callback=lambda pos: _avoid_positions.append(pos))
#What can we see?
_can_see_positions = []
fov.fov(life['pos'],
sight.get_vision(life),
callback=lambda pos: _can_see_positions.append(pos))
#If there are no visible targets, we could be running away from a position we were attacked from
_cover_exposed_at = brain.get_flag(life, 'cover_exposed_at')
if _cover_exposed_at:
_avoid_exposed_cover_positions = set()
for pos in _cover_exposed_at[:]:
if tuple(pos[:2]) in _can_see_positions:
_cover_exposed_at.remove(pos)
continue
fov.fov(
pos,
int(round(sight.get_vision(life) * .25)),
callback=lambda pos: _avoid_exposed_cover_positions.add(pos))
for pos in _avoid_exposed_cover_positions:
if not pos in _avoid_positions:
_avoid_positions.append(pos)
else:
print 'Something went wrong'
return False
#Overlay the two, finding positions we can see but the target can't
for pos in _can_see_positions[:]:
if pos in _avoid_positions:
_can_see_positions.remove(pos)
continue
#Get rid of positions that are too close
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
if bad_numbers.distance(_target['last_seen_at'], pos) < 4:
_can_see_positions.remove(pos)
break
#Now scan for cover to prevent hiding in the open
for pos in _can_see_positions[:]:
if chunks.get_chunk(chunks.get_chunk_key_at(pos))['max_z'] == 2:
_can_see_positions.remove(pos)
if not _can_see_positions:
if life['pos'] in _cover_exposed_at:
_cover_exposed_at.remove(life['pos'])
return False
if lfe.find_action(life, [{
'action': 'dijkstra_move',
'goals': _can_see_positions[:]
}]):
return True
lfe.stop(life)
lfe.add_action(
life, {
'action': 'dijkstra_move',
'rolldown': True,
'zones': _zones,
'goals': _can_see_positions[:],
'reason': 'escaping'
}, 200)
def position_to_attack(life, target, engage_distance):
if lfe.find_action(life, [{
'action': 'dijkstra_move',
'reason': 'positioning for attack'
}]):
if not lfe.ticker(life, 'attack_position', 4):
return False
_target_positions, _zones = combat.get_target_positions_and_zones(
life, [target])
_can_see = alife.sight.can_see_position(life,
_target_positions[0],
get_path=True)
_distance = bad_numbers.distance(life['pos'], _target_positions[0])
if _can_see and len(_can_see) < engage_distance * .85:
if life['path']:
lfe.stop(life)
elif _distance < engage_distance * .9:
_avoid_positions = set()
_target_area = set()
for life_id in alife.judgement.get_trusted(life,
visible=False,
only_recent=True):
fov.fov(LIFE[life_id]['pos'],
int(round(sight.get_vision(life) * .25)),
callback=lambda pos: _avoid_positions.add(pos))
fov.fov(_target_positions[0],
int(round(sight.get_vision(life) * .15)),
callback=lambda pos: _target_area.add(pos))
_min_view_distance = int(round(sight.get_vision(life) * .25))
_max_view_distance = int(round(sight.get_vision(life) * .5))
_attack_positions = set(
zones.dijkstra_map(
life['pos'],
_target_positions,
_zones,
rolldown=True,
return_score_in_range=[_min_view_distance,
_max_view_distance]))
_attack_positions = _attack_positions - _target_area
if not _attack_positions:
return False
if not lfe.find_action(life, [{
'action': 'dijkstra_move',
'orig_goals': list(_attack_positions),
'avoid_positions': list(_avoid_positions)
}]):
lfe.stop(life)
lfe.add_action(
life, {
'action':
'dijkstra_move',
'rolldown':
True,
'goals': [
list(p)
for p in random.sample(_attack_positions,
len(_attack_positions) / 2)
],
'orig_goals':
list(_attack_positions),
'avoid_positions':
list(_avoid_positions),
'reason':
'positioning for attack'
}, 999)
return False
else:
_can_see_positions = set()
_target_area = set()
_avoid_positions = set()
fov.fov(life['pos'],
int(round(sight.get_vision(life) * .75)),
callback=lambda pos: _can_see_positions.add(pos))
fov.fov(_target_positions[0],
int(round(sight.get_vision(life) * .75)),
callback=lambda pos: _target_area.add(pos))
for life_id in alife.judgement.get_trusted(life,
visible=False,
only_recent=True):
_path_dest = lfe.path_dest(LIFE[life_id])
if not _path_dest:
continue
if len(_path_dest) == 2:
_path_dest = list(_path_dest[:])
_path_dest.append(LIFE[life_id]['pos'][2])
fov.fov(_path_dest,
5,
callback=lambda pos: _avoid_positions.add(pos))
_avoid_positions = list(_avoid_positions)
_sneak_positions = _can_see_positions - _target_area
_move_positions = zones.dijkstra_map(LIFE[target]['pos'],
list(_sneak_positions),
_zones,
rolldown=True)
if not _move_positions:
travel_to_position(life, list(_target_positions[0]))
return False
if not lfe.find_action(life, [{
'action': 'dijkstra_move',
'orig_goals': _move_positions,
'avoid_positions': _avoid_positions
}]):
lfe.stop(life)
lfe.add_action(
life, {
'action': 'dijkstra_move',
'rolldown': True,
'goals': [list(p) for p in _move_positions],
'orig_goals': _move_positions,
'avoid_positions': _avoid_positions,
'reason': 'positioning for attack'
}, 999)
return False
return True
def manage_inventory(life):
if manage_hands(life):
return False
for weapon_uid in combat.get_equipped_weapons(life):
if not combat.weapon_is_working(life, weapon_uid):
if combat.weapon_is_in_preferred_working_condition(
life, weapon_uid):
if not len(
lfe.find_action(life,
matches=[{
'action': 'refillammo'
}])):
combat.reload_weapon(life, weapon_uid)
return True
_item_to_wear = {'score': 0, 'item_uid': None}
_item_to_equip = {'score': 0, 'item_uid': None}
for item in [
lfe.get_inventory_item(life, item)
for item in lfe.get_all_unequipped_items(life)
]:
judgement.judge_item(life, item['uid'])
_known_item = brain.get_remembered_item(life, item['uid'])
if _known_item['score']:
if lfe.can_wear_item(life, item['uid']):
if _known_item['score'] > _item_to_wear['score']:
_item_to_wear['score'] = _known_item['score']
_item_to_wear['item_uid'] = item['uid']
else:
if rawparse.raw_has_section(
life, 'items') and rawparse.raw_section_has_identifier(
life, 'items', item['type']):
_action = lfe.execute_raw(life, 'items', item['type'])
if item['type'] == 'gun' and lfe.get_all_equipped_items(
life, matches=[{
'type': 'gun'
}]):
continue
if _action == 'equip':
if _known_item['score'] > _item_to_equip['score']:
_item_to_equip['score'] = _known_item['score']
_item_to_equip['item_uid'] = item['uid']
_item = None
if _item_to_wear['score'] > _item_to_equip['score']:
_item = _item_to_wear['item_uid']
elif _item_to_equip['item_uid']:
_item = _item_to_equip['item_uid']
if _item:
_equip_action = {'action': 'equipitem', 'item': _item}
if len(lfe.find_action(life, matches=[_equip_action])):
return False
lfe.add_action(life,
_equip_action,
401,
delay=lfe.get_item_access_time(life, _item))
return False
return True
def position_to_attack(life, target, engage_distance):
if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "positioning for attack"}]):
if not lfe.ticker(life, "attack_position", 4):
return False
_target_positions, _zones = combat.get_target_positions_and_zones(life, [target])
_can_see = alife.sight.can_see_position(life, _target_positions[0], get_path=True)
_distance = numbers.distance(life["pos"], _target_positions[0])
if _can_see and len(_can_see) < engage_distance * 0.85:
if life["path"]:
lfe.stop(life)
elif _distance < engage_distance * 0.9:
_avoid_positions = set()
_target_area = set()
for life_id in alife.judgement.get_trusted(life, visible=False, only_recent=True):
fov.fov(
LIFE[life_id]["pos"],
int(round(sight.get_vision(life) * 0.25)),
callback=lambda pos: _avoid_positions.add(pos),
)
fov.fov(
_target_positions[0], int(round(sight.get_vision(life) * 0.15)), callback=lambda pos: _target_area.add(pos)
)
_min_view_distance = int(round(sight.get_vision(life) * 0.25))
_max_view_distance = int(round(sight.get_vision(life) * 0.5))
_attack_positions = set(
zones.dijkstra_map(
life["pos"],
_target_positions,
_zones,
rolldown=True,
return_score_in_range=[_min_view_distance, _max_view_distance],
)
)
_attack_positions = _attack_positions - _target_area
if not _attack_positions:
return False
if not lfe.find_action(
life,
[
{
"action": "dijkstra_move",
"orig_goals": list(_attack_positions),
"avoid_positions": list(_avoid_positions),
}
],
):
lfe.stop(life)
lfe.add_action(
life,
{
"action": "dijkstra_move",
"rolldown": True,
"goals": [list(p) for p in random.sample(_attack_positions, len(_attack_positions) / 2)],
"orig_goals": list(_attack_positions),
"avoid_positions": list(_avoid_positions),
"reason": "positioning for attack",
},
999,
)
return False
else:
_can_see_positions = set()
_target_area = set()
_avoid_positions = set()
fov.fov(
life["pos"], int(round(sight.get_vision(life) * 0.75)), callback=lambda pos: _can_see_positions.add(pos)
)
fov.fov(
_target_positions[0], int(round(sight.get_vision(life) * 0.75)), callback=lambda pos: _target_area.add(pos)
)
for life_id in alife.judgement.get_trusted(life, visible=False, only_recent=True):
_path_dest = lfe.path_dest(LIFE[life_id])
if not _path_dest:
continue
if len(_path_dest) == 2:
_path_dest = list(_path_dest[:])
_path_dest.append(LIFE[life_id]["pos"][2])
fov.fov(_path_dest, 5, callback=lambda pos: _avoid_positions.add(pos))
_avoid_positions = list(_avoid_positions)
_sneak_positions = _can_see_positions - _target_area
_move_positions = zones.dijkstra_map(LIFE[target]["pos"], list(_sneak_positions), _zones, rolldown=True)
if not _move_positions:
travel_to_position(life, list(_target_positions[0]))
return False
if not lfe.find_action(
life, [{"action": "dijkstra_move", "orig_goals": _move_positions, "avoid_positions": _avoid_positions}]
):
lfe.stop(life)
lfe.add_action(
life,
{
"action": "dijkstra_move",
"rolldown": True,
"goals": [list(p) for p in _move_positions],
"orig_goals": _move_positions,
"avoid_positions": _avoid_positions,
"reason": "positioning for attack",
},
999,
)
return False
return True
def escape(life, targets):
_target_positions = []
_avoid_positions = []
_zones = [zones.get_zone_at_coords(life['pos'])]
if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'escaping'}]):
if not lfe.ticker(life, 'escaping', 4):
return False
#What can the targets see?
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
_zone = zones.get_zone_at_coords(_target['last_seen_at'])
if not _zone in _zones:
_zones.append(_zone)
fov.fov(_target['last_seen_at'], sight.get_vision(_target['life']), callback=lambda pos: _avoid_positions.append(pos))
#What can we see?
_can_see_positions = []
fov.fov(life['pos'], sight.get_vision(life), callback=lambda pos: _can_see_positions.append(pos))
#If there are no visible targets, we could be running away from a position we were attacked from
_cover_exposed_at = brain.get_flag(life, 'cover_exposed_at')
if _cover_exposed_at:
_avoid_exposed_cover_positions = set()
for pos in _cover_exposed_at[:]:
if tuple(pos[:2]) in _can_see_positions:
print 'ok!!!'*20
_cover_exposed_at.remove(pos)
continue
fov.fov(pos, int(round(sight.get_vision(life)*.25)), callback=lambda pos: _avoid_exposed_cover_positions.add(pos))
for pos in _avoid_exposed_cover_positions:
if not pos in _avoid_positions:
_avoid_positions.append(pos)
#Overlay the two, finding positions we can see but the target can't
for pos in _can_see_positions[:]:
if pos in _avoid_positions:
_can_see_positions.remove(pos)
continue
#Get rid of positions that are too close
for target_id in targets:
_target = brain.knows_alife_by_id(life, target_id)
#TODO: Unhardcode 15
if numbers.distance(_target['last_seen_at'], pos)<10:
_can_see_positions.remove(pos)
break
#Now scan for cover to prevent hiding in the open
for pos in _can_see_positions[:]:
if chunks.get_chunk(chunks.get_chunk_key_at(pos))['max_z'] == 2:
_can_see_positions.remove(pos)
#for target_id in targets:
#_target = brain.knows_alife_by_id(life, target_id)
#_target_positions.append(_target['last_seen_at'][:])
#_zone = zones.get_zone_at_coords(_target['last_seen_at'])
#if not _zone in _zones:
# _zones.append(_zone)
#for chunk_key in chunks.get_visible_chunks_from(_target['last_seen_at'], sight.get_vision(_target['life'])):
# if chunk_key in _visible_target_chunks:
# continue
# _visible_target_chunks.append(chunk_key)
#for friendly_id in life['seen']:
# _chunk_key = lfe.get_current_chunk_id(LIFE[friendly_id])
#
# if not _chunk_key in _visible_target_chunks:
# _visible_target_chunks.append(_chunk_key)
#if not _target_positions:
# return False
#TODO: #combat: For lower limit in return_score_in_range, use range of weapon
#_cover = zones.dijkstra_map(life['pos'],
# _avoid_positions,
# _zones,
# avoid_chunks=[],
# return_score_in_range=[1, 5]) # sight.get_vision(life)
#_cover = [(c[0], c[1], life['pos'][2]) for c in _cover]
#if not _cover:
# return False
#_zones = [zones.get_zone_at_coords(life['pos'])]
#for _pos in _cover:
# _zone = zones.get_zone_at_coords(_pos)
# if not _zone in _zones:
# _zones.append(_zone)
if not _can_see_positions:
return False
if lfe.find_action(life, [{'action': 'dijkstra_move', 'goals': _can_see_positions[:]}]):
return True
lfe.stop(life)
lfe.add_action(life, {'action': 'dijkstra_move',
'rolldown': True,
'zones': _zones,
'goals': _can_see_positions[:],
'reason': 'escaping'},
999)
