def judge_self(life):
_confidence = 0
_limb_confidence = 0
for limb in [life["body"][limb] for limb in life["body"]]:
# TODO: Mark as target?
if not limb["bleeding"]:
_limb_confidence += 1
if not limb["bruised"]:
_limb_confidence += 2
if not limb["broken"]:
_limb_confidence += 3
# TODO: There's a chance to fake confidence here
# If we're holding a gun, that's all the other ALifes see
# and they judge based on that (unless they've heard you run
# out of ammo.)
# For now we'll consider ammo just because we can...
_self_armed = lfe.get_held_items(life, matches=[{"type": "gun"}])
if _self_armed:
_weapon = lfe.get_inventory_item(life, _self_armed[0])
_feed = weapons.get_feed(_weapon)
if _feed and _feed["rounds"]:
_confidence += 30
else:
_confidence -= 30
return _confidence + _limb_confidence
def judge_self(life):
_confidence = 0
_limb_confidence = 0
for limb in [life['body'][limb] for limb in life['body']]:
#TODO: Mark as target?
if not limb['bleeding']:
_limb_confidence += 1
if not limb['bruised']:
_limb_confidence += 2
if not limb['broken']:
_limb_confidence += 3
#TODO: There's a chance to fake confidence here
#If we're holding a gun, that's all the other ALifes see
#and they judge based on that (unless they've heard you run
#out of ammo.)
#For now we'll consider ammo just because we can...
_self_armed = lfe.get_held_items(life,matches=[{'type': 'gun'}])
if _self_armed:
_weapon = lfe.get_inventory_item(life,_self_armed[0])
_feed = weapons.get_feed(_weapon)
if _feed and _feed['rounds']:
_confidence += 30
else:
_confidence -= 30
return _confidence+_limb_confidence
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 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 get_recoil(life):
_guns = lfe.get_held_items(life,matches=[{'type': 'gun'}])
if not _guns:
return 0
weapon = lfe.get_inventory_item(life, _guns[0])
_recoil = weapon['recoil']
_recoil *= get_stance_recoil_mod(life)
return _recoil
def get_recoil(life):
_guns = lfe.get_held_items(life, matches=[{'type': 'gun'}])
if not _guns:
return 0
weapon = lfe.get_inventory_item(life, _guns[0])
_recoil = weapon['recoil']
_recoil *= get_stance_recoil_mod(life)
return _recoil
def get_ranged_combat_ready_score(life, consider_target_id=None):
_score = 0
if consider_target_id:
_target = brain.knows_alife_by_id(life, consider_target_id)
#TODO: Judge proper distance based on weapon equip time
if bad_numbers.distance(life['pos'], _target['last_seen_at'])<sight.get_vision(life)/2:
if lfe.get_held_items(life, matches=[{'type': 'gun'}]):
_score += 1
elif lfe.get_all_inventory_items(life, matches=[{'type': 'gun'}]):
_score += 1
return _score
def get_ranged_combat_ready_score(life, consider_target_id=None):
_score = 0
if consider_target_id:
_target = brain.knows_alife_by_id(life, consider_target_id)
# TODO: Judge proper distance based on weapon equip time
if numbers.distance(life["pos"], _target["last_seen_at"]) < sight.get_vision(life) / 2:
if lfe.get_held_items(life, matches=[{"type": "gun"}]):
_score += 1
elif lfe.get_all_inventory_items(life, matches=[{"type": "gun"}]):
_score += 1
return _score
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 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 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.clear_actions(life)
lfe.add_action(life,{'action': 'move','to': _highest['item']['pos'][:2]},200)
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 _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 get_weapon_to_fire(life):
if 'player' in life:
return life['firing']
_item = lfe.get_held_items(life,matches=[{'type': 'gun'}])
if _item:
_item = _item[0]
else:
return False
if not _item:
if 'player' in life:
gfx.message('You aren\'t holding a weapon!')
life['firing'] = None
return False
return lfe.get_inventory_item(life, _item)
def get_weapon_to_fire(life):
if 'player' in life:
return life['firing']
_item = lfe.get_held_items(life, matches=[{'type': 'gun'}])
if _item:
_item = _item[0]
else:
return False
if not _item:
if 'player' in life:
gfx.message('You aren\'t holding a weapon!')
life['firing'] = None
return False
return lfe.get_inventory_item(life, _item)
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 _create_context_from_phrase(life, phrase):
_reactions = []
if phrase['gist'] == 'comply':
_reactions.append({'type': 'say','text': 'I give up!',
'communicate': 'surrender'})
if lfe.get_held_items(life, matches=[{'type': 'gun'}]):
_reactions.append({'action': 'action',
'text': '<Shoot %s>' % ' '.join(phrase['from']['name'])})
elif phrase['gist'] == 'demand_drop_item':
_reactions.append({'type': 'action','text': 'Drop the item.',
'action': {'action': 'dropitem','item': phrase['item']},
'score': 900,
'delay': lfe.get_item_access_time(life,phrase['item']),
'communicate': 'dropped_demanded_item'})
elif phrase['gist'] == 'dialog':
if not phrase['dialog_id'] in LIFE[SETTINGS['controlling']]['dialogs']:
life['dialogs'].append(phrase['dialog_id'])
if dialog.get_last_message(phrase['dialog_id'])['text']:
logic.show_event(dialog.get_last_message(phrase['dialog_id'])['text'], life=phrase['from'])
if dialog.is_turn_to_talk(LIFE[SETTINGS['controlling']], phrase['dialog_id']):
dialog.process(LIFE[SETTINGS['controlling']], phrase['dialog_id'])
elif phrase['gist'] == 'looks_hostile':
#encounters.create_encounter(life, phrase['from'])
#logic.show_event(
alife.speech.start_dialog(phrase['from'], life['id'], 'encounter')
#else:
# logging.warning('Unhandled player context: %s' % phrase['gist'])
return _reactions
def get_equipped_weapons(life):
return lfe.get_held_items(life, matches=[{'type': 'gun'}])
def is_any_weapon_equipped(life):
if lfe.get_held_items(life, matches=[{'type': 'gun'}]):
return True
return False
def get_equipped_weapons(life):
return lfe.get_held_items(life, matches=[{'type': 'gun'}])
def is_any_weapon_equipped(life):
if lfe.get_held_items(life, matches=[{'type': 'gun'}]):
return True
return False
def create_function_map():
FUNCTION_MAP.update({'is_family': stats.is_family,
'name': lambda life: ' '.join(life['name']),
'is_same_species': stats.is_same_species,
'can_trust': judgement.can_trust,
'is_dangerous': judgement.is_target_dangerous,
'can_bite': stats.can_bite,
'can_scratch': stats.can_scratch,
'weapon_equipped_and_ready': combat.weapon_equipped_and_ready,
'prepare_for_ranged': combat.prepare_for_ranged,
'explore_unknown_chunks': survival.explore_unknown_chunks,
'is_nervous': stats.is_nervous,
'is_aggravated': stats.is_aggravated,
'is_scared': judgement.is_scared,
'is_safe': judgement.is_safe,
'is_healthy': None,
'is_intimidated': stats.is_intimidated,
'is_intimidating': lambda life, life_id: stats.is_intimidated_by(LIFE[life_id], life['id']),
'is_confident': stats.is_confident,
'is_situation_tense': lambda life: judgement.get_tension(life)>=10,
'is_combat_ready': lambda life, life_id: not LIFE[life_id]['state'] in ['hiding', 'hidden'],
'is_surrendering': lambda life, life_id: LIFE[life_id]['state'] == 'surrender',
'is_being_surrendered_to': lambda life: len(judgement.get_combat_targets(life, ignore_escaped=True, filter_func=lambda life, life_id: LIFE[life_id]['state'] == 'surrender'))>0,
'closest': None,
'kill': lambda life: lfe.kill(life, 'their own dumb self'),
'has_attacked_trusted': stats.has_attacked_trusted,
'has_attacked_self': stats.has_attacked_self,
'distance_to_pos': stats.distance_from_pos_to_pos,
'current_chunk_has_flag': lambda life, flag: chunks.get_flag(life, lfe.get_current_chunk_id(life), flag)>0,
'is_idle': lambda life: life['state'] == 'idle',
'is_relaxed': lambda life: life['state_tier'] == TIER_RELAXED,
'is_child_of': stats.is_child_of,
'is_parent_of': stats.is_parent_of,
'has_parent': stats.has_parent,
'has_child': stats.has_child,
'is_night': logic.is_night,
'is_born_leader': stats.is_born_leader,
'is_psychotic': stats.is_psychotic,
'is_safe_in_shelter': stats.is_safe_in_shelter,
'is_incapacitated': stats.is_incapacitated,
'is_target': lambda life, life_id: life_id in judgement.get_targets(life) or life_id in judgement.get_combat_targets(life),
'seen_target_recently': lambda life, life_id: brain.knows_alife_by_id(life, life_id)['last_seen_time']<=150,
'is_combat_target': lambda life, life_id: life_id in judgement.get_combat_targets(life),
'is_traitor': lambda life, life_id: len(lfe.get_memory(life, matches={'text': 'traitor', 'target': life_id}))>0,
'is_awake': judgement.is_target_awake,
'is_dead': judgement.is_target_dead,
'is_target_dead': judgement.is_target_dead,
'is_raiding': lambda life: (life['group'] and groups.get_stage(life, life['group'])==STAGE_RAIDING)==True,
'find_and_announce_shelter': groups.find_and_announce_shelter,
'desires_shelter': stats.desires_shelter,
'travel_to_position': movement.travel_to_position,
'find_target': movement.find_target,
'can_see_target': sight.can_see_target,
'has_threats': lambda life: len(judgement.get_threats(life, ignore_escaped=1))>0,
'has_visible_threat': lambda life: len(judgement.get_visible_threats(life))>0,
'has_combat_targets': lambda life: len(judgement.get_combat_targets(life))>0,
'has_lost_threat': lambda life: len(judgement.get_threats(life, escaped_only=True, ignore_escaped=2))>0,
'has_ready_combat_targets': lambda life: len(judgement.get_ready_combat_targets(life, recent_only=True, limit_distance=sight.get_vision(life)+10))>0,
'danger_close': stats.is_threat_too_close,
'number_of_alife_in_chunk_matching': lambda life, chunk_key, matching, amount: len(chunks.get_alife_in_chunk_matching(chunk_key, matching))>amount,
'number_of_alife_in_reference_matching': lambda life, reference_id, matching, amount: len(references.get_alife_in_reference_matching(reference_id, matching))>amount,
'announce_to_group': groups.announce,
'is_in_chunk': chunks.is_in_chunk,
'is_in_shelter': lfe.is_in_shelter,
'has_shelter': lambda life: len(judgement.get_known_shelters(life))>0,
'has_completed_job': lambda life, job_id: job_id in life['completed_jobs'],
'has_completed_task': lambda life, job_id: job_id in life['completed_jobs'],
'retrieve_from_memory': brain.retrieve_from_memory,
'pick_up_and_hold_item': lfe.pick_up_and_hold_item,
'has_usable_weapon': lambda life: not combat.has_ready_weapon(life) == False,
'has_potentially_usable_weapon': lambda life: combat.has_potentially_usable_weapon(life) == True,
'target_is_combat_ready': judgement.target_is_combat_ready,
'create_item_need': survival.add_needed_item,
'group_needs_resources': lambda life, group_id: groups.needs_resources(group_id),
'has_needs_to_meet': survival.has_needs_to_meet,
'has_unmet_needs': survival.has_unmet_needs,
'has_needs_to_satisfy': survival.has_needs_to_satisfy,
'has_needs': lambda life: survival.has_needs_to_meet(life) or survival.has_unmet_needs(life) or survival.has_needs_to_satisfy(life),
'has_number_of_items_matching': lambda life, matching, amount: len(lfe.get_all_inventory_items(life, matches=matching))>=amount,
'flag_item_matching': lambda life, matching, flag: lfe.get_all_inventory_items(life, matches=[matching]) and brain.flag_item(life, lfe.get_all_inventory_items(life, matches=[matching])[0], flag)>0,
'drop_item_matching': lambda life, matching: lfe.get_all_inventory_items(life, matches=[matching]) and lfe.drop_item(life, lfe.get_all_inventory_items(life, matches=[matching])[0]['uid'])>0,
'has_target_to_follow': lambda life: judgement.get_target_to_follow(life)>0,
'has_target_to_guard': lambda life: judgement.get_target_to_guard(life)>0,
'get_recent_events': speech.get_recent_events,
'get_target': lambda life, life_id: speech.get_target(life,
lfe.has_dialog_with(life, life_id),
dialog.get_flag(lfe.has_dialog_with(life, life_id),
'NEXT_GIST')),
'get_needs': lambda life, life_id: speech.get_needs(life,
lfe.has_dialog_with(life, life_id),
dialog.get_flag(lfe.has_dialog_with(life, life_id),
'NEXT_GIST')),
'get_location': lambda life: '%s, %s' % (life['pos'][0], life['pos'][1]),
'join_group': lambda life, **kwargs: groups.join_group(life, kwargs['group_id']),
'add_group_member': lambda life, life_id: groups.add_member(life, life['group'], life_id),
'claim_to_be_group_leader': lambda life, life_id: groups.set_leader(life, life['group'], life['id']),
'is_group_leader': lambda life: groups.is_leader_of_any_group(life)==True,
'is_in_same_group': lambda life, life_id: (life['group'] and LIFE[life_id]['group'] == life['group'])>0,
'is_target_group_leader': lambda life, life_id: (groups.is_leader_of_any_group(LIFE[life_id]))==True,
'is_in_group': lambda life: life['group']>0,
'is_target_hostile': lambda life, life_id: brain.knows_alife_by_id(life, life_id) and brain.knows_alife_by_id(life, life_id)['alignment'] == 'hostile',
'is_target_in_group': lambda life, life_id, **kwargs: brain.knows_alife_by_id(life, life_id) and brain.knows_alife_by_id(life, life_id)['group']==kwargs['group'],
'is_target_in_any_group': lambda life, life_id: brain.knows_alife_by_id(life, life_id) and brain.knows_alife_by_id(life, life_id)['group']>0,
'is_target_group_friendly': lambda life, life_id: brain.knows_alife_by_id(life, life_id) and brain.knows_alife_by_id(life, life_id)['group'] and groups.get_group_memory(life, brain.knows_alife_by_id(life, life_id)['group'], 'alignment')=='trust',
'is_target_group_hostile': groups.is_target_group_hostile,
'is_target_group_neutral': lambda life, life_id: brain.knows_alife_by_id(life, life_id) and brain.knows_alife_by_id(life, life_id)['group'] and groups.get_group_memory(life, brain.knows_alife_by_id(life, life_id)['group'], 'alignment')=='neutral',
'is_group_hostile': lambda life, **kwargs: groups.get_group_memory(life, kwargs['group_id'], 'alignment')=='hostile',
'is_injured': lambda life: len(lfe.get_cut_limbs(life)) or len(lfe.get_bleeding_limbs(life)),
'inform_of_group_members': speech.inform_of_group_members,
'update_group_members': speech.update_group_members,
'get_group_flag': groups.get_flag,
'get_flag': brain.get_flag,
'get_group': lambda life: life['group'],
'discover_group': lambda life, **kwargs: groups.discover_group(life, kwargs['group_id']),
'add_target_to_known_group': lambda life, life_id, **kwargs: groups.add_member(life, kwargs['group_id'], life_id),
'knows_about_group': lambda life, **kwargs: groups.group_exists(life, kwargs['group_id']),
'group_has_shelter': lambda life: groups.get_shelter(life, life['group'])>0,
'declare_group_hostile': lambda life, **kwargs: stats.declare_group_hostile(life, kwargs['group_id']),
'declare_group_trusted': lambda life, **kwargs: stats.declare_group_trusted(life, kwargs['group_id']),
'declare_group_target': lambda life, life_id: stats.declare_group_target(life, life_id, 'hostile'),
'get_group_shelter': lambda life: groups.get_shelter(life, life['group']),
'set_group_shelter': lambda life, **kwargs: groups.set_shelter(life, kwargs['group_id'], kwargs['shelter']),
'get_group_stage': lambda life: groups.get_stage(life, life['group']),
'get_group_stage_message': speech.get_group_stage_message,
'set_group_stage': lambda life, **kwargs: groups.set_stage(life, kwargs['group_id'], kwargs['stage']),
'is_group_motivated_for_crime': lambda life: life['group'] and groups.get_motive(life, life['group']) == 'crime',
'wants_to_leave_group_for_group': lambda life: stats.wants_to_abandon_group(life, life['group']),
'knows_items_matching': lambda life, **kwargs: len(brain.get_multi_matching_remembered_items(life, kwargs['items'], no_owner=True))>0,
'get_known_group': speech.get_known_group,
'inform_of_group': speech.inform_of_group,
'force_inform_of_group': speech.force_inform_of_group,
'inform_of_items': lambda life, life_id, **kwargs: speech.inform_of_items(life, life_id, kwargs['items']),
'update_location': lambda life, life_id: brain.update_known_life(life, life_id, 'last_seen_at', LIFE[life_id]['pos'][:]),
'has_questions_for_target': lambda life, life_id: len(memory.get_questions_for_target(life, life_id))>0,
'has_orders_for_target': lambda life, life_id: len(memory.get_orders_for_target(life, life_id))>0,
'ask_target_question': memory.ask_target_question,
'give_target_order_message': memory.give_target_order_message,
'give_target_order': memory.give_target_order,
'take_order': memory.take_order,
'reject_order': memory.reject_order,
'get_introduction_message': speech.get_introduction_message,
'get_introduction_gist': speech.get_introduction_gist,
'establish_trust': stats.establish_trust,
'establish_feign_trust': stats.establish_feign_trust,
'establish_aggressive': stats.establish_aggressive,
'establish_hostile': stats.establish_hostile,
'establish_scared': stats.establish_scared,
'claim_hostile': lambda life, target, **kwargs: stats.establish_hostile(life, kwargs['target_id']),
'describe_target': lambda life, life_id, **kwargs: speech.describe_target(life, kwargs['target']),
'consume': lfe.consume,
'explode': items.explode,
'is_player': lambda life: 'player' in life,
'is_neutral': lambda life, life_id: brain.knows_alife_by_id(life, life_id)['alignment'] == 'neutral',
'reset_think_timer': lfe.reset_think_rate,
'mark_target_as_combat_ready': lambda life, life_id: brain.flag_alife(life, life_id, 'combat_ready'),
'mark_target_as_not_combat_ready': lambda life, life_id: brain.flag_alife(life, life_id, 'combat_ready', value=False),
'saw_target_recently': lambda life, **kwargs: brain.knows_alife_by_id(life, kwargs['target_id']) and -1<brain.knows_alife_by_id(life, kwargs['target_id'])['last_seen_time']<6000,
'update_location_of_target_from_target': speech.update_location_of_target_from_target,
'ping': lambda life: logging.debug('%s: Ping!' % ' '.join(life['name'])),
'wander': lambda life: alife_discover.tick(life),
'pick_up_item': lambda life: alife_needs.tick(life),
'take_shelter': lambda life: alife_shelter.tick(life),
'has_non_relaxed_goal': lambda life: life['state_tier']>TIER_RELAXED,
'needs_to_manage_inventory': lambda life: alife_manage_items.conditions(life) == True,
'manage_inventory': lambda life: alife_manage_items.tick(life),
'cover_exposed': lambda life: len(combat.get_exposed_positions(life))>0,
'ranged_ready': lambda life: lfe.execute_raw(life, 'combat', 'ranged_ready'),
'ranged_attack': lambda life: alife_combat.ranged_attack(life),
'melee_ready': lambda life: lfe.execute_raw(life, 'combat', 'melee_ready'),
'melee_attack': lambda life: alife_combat.melee_attack(life),
'take_cover': lambda life: alife_cover.tick(life),
'hide': lambda life: alife_escape.tick(life),
'stop': lfe.stop,
'search_for_threat': lambda life: alife_search.tick(life),
'has_low_recoil': lambda life: life['recoil']>=.25,
'has_medium_recoil': lambda life: life['recoil']>=.5,
'has_high_recoil': lambda life: life['recoil']>=.75,
'has_focus_point': lambda life: len(lfe.get_memory(life, matches={'text': 'focus_on_chunk'}))>0,
'walk_to': lambda life: movement.travel_to_chunk(life, lfe.get_memory(life, matches={'text': 'focus_on_chunk'})[len(lfe.get_memory(life, matches={'text': 'focus_on_chunk'}))-1]['chunk_key']),
'follow_target': alife_follow.tick,
'guard_focus_point': lambda life: movement.guard_chunk(life, lfe.get_memory(life, matches={'text': 'focus_on_chunk'})[0]['chunk_key']),
'disarm': lambda life, life_id: brain.flag_alife(life, life_id, 'disarm', value=WORLD_INFO['ticks']),
'drop_weapon': lambda life: lfe.drop_item(life, lfe.get_held_items(life, matches={'type': 'gun'})[0]),
'is_disarming': lambda life, life_id: brain.get_alife_flag(life, life_id, 'disarm')>0,
'set_raid_location': lambda life, **kwargs: lfe.memory(life, 'focus_on_chunk', chunk_key=kwargs['chunk_key']),
'move_to_chunk': lambda life, **kwargs: movement.set_focus_point(life, kwargs['chunk_key']),
'move_to_chunk_key': movement.set_focus_point,
'recruiting': lambda life, life_id: speech.send(life, life_id, 'recruit'),
'is_raiding': lambda life: life['group'] and groups.get_stage(life, life['group']) == STAGE_ATTACKING,
'is_in_target_chunk': lambda life, target_id: lfe.get_current_chunk_id(life) == lfe.get_current_chunk_id(LIFE[target_id]),
'get_chunk_key': lfe.get_current_chunk_id,
'has_threat_in_combat_range': stats.has_threat_in_combat_range,
'find_nearest_chunk_in_reference': references.find_nearest_chunk_key_in_reference_of_type,
'has_item_type': lambda life, item_match: not lfe.get_inventory_item_matching(life, item_match) == None,
'move_to_target': lambda life, target_id: movement.travel_to_position(life, LIFE[target_id]['pos']),
'is_in_range_of_target': lambda life, target_id, distance: numbers.distance(life['pos'], LIFE[target_id]['pos'])<=int(distance),
'track_target': lambda life, target_id: brain.meet_alife(life, LIFE[target_id]) and judgement.track_target(life, target_id),
'untrack_target': judgement.untrack_target,
'clear_tracking': lambda life: brain.flag(life, 'tracking_targets', []),
'can_see_item': lambda life, item_uid: item_uid in life['seen_items'],
'has_item': lambda life, item_uid: item_uid in life['inventory'],
'pick_up_item': movement.pick_up_item,
'create_mission': missions.create_mission_for_self,
'give_mission': missions.create_mission_and_give,
'do_mission': alife_work.tick,
'has_mission': lambda life: len(life['missions'])>0,
'drop_item': lfe.drop_item,
'get_id': lambda life: life['id'],
'always': lambda life: 1==1,
'pass': lambda life, *a, **k: True,
'never': lambda life: 1==2})
