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 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 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)