Example #1
0
def is_confident(life):
    if 'player' in life:
        return False

    _friendly_confidence = judgement.get_ranged_combat_rating_of_target(
        life, life['id'])
    _threat_confidence = 0

    for target_id in judgement.get_trusted(life, visible=False):
        _knows = brain.knows_alife_by_id(life, target_id)

        if _knows['dead'] or _knows['asleep']:
            continue

        if _knows['last_seen_time'] > 30:
            if brain.get_alife_flag(life, target_id, 'threat_score'):
                _recent_mod = 1 - (
                    numbers.clip(_knows['last_seen_time'], 0, 300) / 300.0)
                _score = brain.get_alife_flag(life, target_id, 'threat_score')
                _friendly_confidence += _score * _recent_mod
            else:
                _friendly_confidence += 1
        else:
            _score = judgement.get_ranged_combat_rating_of_target(
                life, target_id)

            brain.flag_alife(life, target_id, 'threat_score', value=_score)

            _friendly_confidence += _score

    for target_id in judgement.get_threats(life, ignore_escaped=False):
        _knows = brain.knows_alife_by_id(life, target_id)

        if _knows['dead'] or _knows['asleep']:
            continue

        if _knows['last_seen_time']:
            if brain.get_alife_flag(life, target_id, 'threat_score'):
                if _knows['last_seen_time'] > 50:
                    _recent_mod = 1 - (
                        numbers.clip(_knows['last_seen_time'], 0, 600) / 600.0)
                else:
                    _recent_mod = 1

                _score = brain.get_alife_flag(life, target_id, 'threat_score')
                _threat_confidence += _score * _recent_mod
            else:
                _threat_confidence += 1
        else:
            _score = judgement.get_ranged_combat_rating_of_target(
                life, target_id, inventory_check=False)

            brain.flag_alife(life, target_id, 'threat_score', value=_score)

            _threat_confidence += _score

    return _friendly_confidence - _threat_confidence >= -2
Example #2
0
def is_confident(life):
	if 'player' in life:
		return False
	
	_friendly_confidence = judgement.get_ranged_combat_rating_of_target(life, life['id'])
	_threat_confidence = 0
	
	for target_id in judgement.get_trusted(life, visible=False):
		_knows = brain.knows_alife_by_id(life, target_id)
		
		if _knows['dead'] or _knows['asleep']:
			continue
		
		if _knows['last_seen_time']>30:
			if brain.get_alife_flag(life, target_id, 'threat_score'):
				_recent_mod = 1-(numbers.clip(_knows['last_seen_time'], 0, 300)/300.0)
				_score = brain.get_alife_flag(life, target_id, 'threat_score')
				_friendly_confidence += _score*_recent_mod
			else:
				_friendly_confidence += 1
		else:
			_score = judgement.get_ranged_combat_rating_of_target(life, target_id)
			
			brain.flag_alife(life, target_id, 'threat_score', value=_score)
			
			_friendly_confidence += _score
	
	for target_id in judgement.get_threats(life, ignore_escaped=False):
		_knows = brain.knows_alife_by_id(life, target_id)
		
		if _knows['dead'] or _knows['asleep']:
			continue
		
		if _knows['last_seen_time']:
			if brain.get_alife_flag(life, target_id, 'threat_score'):
				if _knows['last_seen_time']>50:
					_recent_mod = 1-(numbers.clip(_knows['last_seen_time'], 0, 600)/600.0)
				else:
					_recent_mod = 1
				
				_score = brain.get_alife_flag(life, target_id, 'threat_score')
				_threat_confidence += _score*_recent_mod
			else:
				_threat_confidence += 1
		else:
			_score = judgement.get_ranged_combat_rating_of_target(life, target_id, inventory_check=False)
			
			brain.flag_alife(life, target_id, 'threat_score', value=_score)
			
			_threat_confidence += _score
	
	return _friendly_confidence-_threat_confidence>=-2
Example #3
0
def prepare_for_raid(life, group_id):
    #_target_group = get_flag(life, group_id, 'raid_target')

    announce(life,
             group_id,
             'combat_ready',
             ignore_if_said_in_last=1000,
             filter_if=lambda alife_id: brain.get_alife_flag(
                 life, LIFE[alife_id], 'combat_ready'))
Example #4
0
def is_family(life, life_id):
    _know = brain.knows_alife_by_id(life, life_id)

    if not _know:
        return False

    for relation in ['son', 'daughter', 'mother', 'father', 'sibling']:
        if brain.get_alife_flag(life, life_id, relation):
            return True

    return False
Example #5
0
def is_parent_of(life, life_id):
    _know = brain.knows_alife_by_id(life, life_id)

    if not _know:
        return False

    for relation in ['son', 'daughter']:
        if brain.get_alife_flag(life, life_id, relation):
            return True

    return False
Example #6
0
def is_parent_of(life, life_id):
	_know = brain.knows_alife_by_id(life, life_id)
	
	if not _know:
		return False
	
	for relation in ['son', 'daughter']:
		if brain.get_alife_flag(life, life_id, relation):
			return True
	
	return False
Example #7
0
def is_family(life, life_id):
	_know = brain.knows_alife_by_id(life, life_id)
	
	if not _know:
		return False
	
	for relation in ['son', 'daughter', 'mother', 'father', 'sibling']:
		if brain.get_alife_flag(life, life_id, relation):
			return True
	
	return False
Example #8
0
def judge_raid(life, raiders, camp):
	# score >= 0: We can handle it
	# 		<  0: We can't handle it 
	_score = 0
	for raider in raiders:
		_knows = brain.knows_alife_by_id(life, raider)
		if not _knows:
			#TODO: Confidence
			_score -= 2
			continue
		
		#TODO: Find a better way to do this
		#TODO: This has to be broken: _knows['life']
		if not brain.get_alife_flag(life, raider, 'combat_score'):
			judge_life(life, raider)
		
		if brain.get_alife_flag(life, raider, 'combat_score'):
			_score += _knows['flags']['combat_score']
	
	logging.debug('RAID: %s judged raid with score %s' % (' '.join(life['name']), _score))
	
	return _score
Example #9
0
def judge_raid(life, raiders, camp):
    # score >= 0: We can handle it
    # 		<  0: We can't handle it
    _score = 0
    for raider in raiders:
        _knows = brain.knows_alife_by_id(life, raider)
        if not _knows:
            # TODO: Confidence
            _score -= 2
            continue

            # TODO: Find a better way to do this
            # TODO: This has to be broken: _knows['life']
        if not brain.get_alife_flag(life, raider, "combat_score"):
            judge_life(life, raider)

        if brain.get_alife_flag(life, raider, "combat_score"):
            _score += _knows["flags"]["combat_score"]

    logging.debug("RAID: %s judged raid with score %s" % (" ".join(life["name"]), _score))

    return _score
Example #10
0
def is_combat_ready(life, group_id):
	_combat_readiness = 0
	
	for member in get_group(life, group_id)['members']:
		if life['id'] == member:
			continue
		
		_combat_readiness += brain.get_alife_flag(life, member, 'combat_ready')
	
	if _combat_readiness >= 3:
		#update_group_memory(life, target_group_id, 'al
		return True
	else:
		return False
Example #11
0
def is_combat_ready(life, group_id):
    _combat_readiness = 0

    for member in get_group(life, group_id)['members']:
        if life['id'] == member:
            continue

        _combat_readiness += brain.get_alife_flag(life, member, 'combat_ready')

    if _combat_readiness >= 3:
        #update_group_memory(life, target_group_id, 'al
        return True
    else:
        return False
Example #12
0
def is_child_of(life, life_id):
	_know = brain.knows_alife_by_id(life, life_id)

	if not _know:
		return False
	
	if not _know['escaped'] and _know['life']['dead']:
		return False
	
	for relation in ['mother', 'father']:
		if brain.get_alife_flag(life, life_id, relation):
			return True
	
	return False
Example #13
0
def search_for_target(life, target_id):
	#TODO: Variable size instead of hardcoded
	_know = brain.knows_alife_by_id(life, target_id)
	_size = 30
	
	if brain.alife_has_flag(life, target_id, 'search_map'):
		_search_map = brain.get_alife_flag(life, target_id, 'search_map')
	else:
		_search_map = maps.create_search_map(life, _know['last_seen_at'], _size)
		brain.flag_alife(life, target_id, 'search_map', value=_search_map)
		
		lfe.stop(life)
		lfe.walk_to(life, _know['last_seen_at'][:2])
	
	if life['path'] or lfe.find_action(life, matches=[{'action': 'move'}]):
		return False
	
	_lowest = {'score': -1, 'pos': None}
	_x_top_left = numbers.clip(_know['last_seen_at'][0]-(_size/2), 0, MAP_SIZE[0])
	_y_top_left = numbers.clip(_know['last_seen_at'][1]-(_size/2), 0, MAP_SIZE[1])
	
	for x in range(0, _size):
		_x = _x_top_left+x
		
		if _x >= MAP_SIZE[0]-1:
			continue
		
		for y in range(0, _size):
			_y = _y_top_left+y
			
			if _y >= MAP_SIZE[1]-1:
				continue
			
			if not _search_map[y, x]:
				continue
			
			if sight.can_see_position(life, (_x, _y)):
				_search_map[y, x] = 0
			
			if _search_map[y, x]>0 and (not _lowest['pos'] or _search_map[y, x] <= _lowest['score']):
				_lowest['score'] = _search_map[y, x]
				_lowest['pos'] = (_x, _y, x, y)

	if _lowest['pos']:
		x, y, _x, _y = _lowest['pos']
		
		if travel_to_position(life, (x, y, _know['last_seen_at'][2]), stop_on_sight=True):
			_search_map[_y, _x] = 0
	else:
		_know['escaped'] = 2
Example #14
0
def is_child_of(life, life_id):
    _know = brain.knows_alife_by_id(life, life_id)

    if not _know:
        return False

    if not _know['escaped'] and _know['life']['dead']:
        return False

    for relation in ['mother', 'father']:
        if brain.get_alife_flag(life, life_id, relation):
            return True

    return False
Example #15
0
def react_to_tension(life, life_id):
    if brain.knows_alife_by_id(life, life_id)['alignment'] in ['hostile']:
        return False

    if life['group'] and not groups.is_leader(
            life, life['group'], life['id']) and groups.get_leader(
                life, life['group']):
        if sight.can_see_target(life, groups.get_leader(
                life, life['group'])) and sight.can_see_target(
                    LIFE[life_id], groups.get_leader(life, life['group'])):
            return False

    _disarm = brain.get_alife_flag(life, life_id, 'disarm')

    if _disarm:
        #For now...
        if not sight.can_see_position(life, LIFE[life_id]['pos']):
            groups.announce(life,
                            life['group'],
                            'attacked_by_hostile',
                            filter_if=lambda life_id: brain.knows_alife_by_id(
                                life, life_id)['last_seen_time'] <= 30,
                            target_id=life_id)

            return False

        for item_uid in lfe.get_all_visible_items(LIFE[life_id]):
            if ITEMS[item_uid]['type'] == 'gun':
                break
        else:
            brain.unflag_alife(life, life_id, 'disarm')
            speech.start_dialog(life, life_id, 'clear_drop_weapon')

            return False

        _time_elapsed = WORLD_INFO['ticks'] - _disarm

        if _time_elapsed > 135 and not speech.has_sent(life, life_id,
                                                       'threaten'):
            speech.start_dialog(life, life_id, 'threaten')
            speech.send(life, life_id, 'threaten')
        elif _time_elapsed > 185:
            speech.start_dialog(life, life_id, 'establish_hostile')
    elif not speech.has_sent(life, life_id, 'confront'):
        speech.start_dialog(life, life_id, 'confront')
        speech.send(life, life_id, 'confront')
Example #16
0
def react_to_tension(life, life_id):
	if brain.knows_alife_by_id(life, life_id)['alignment'] in ['hostile']:
		return False
	
	if life['group'] and not groups.is_leader(life, life['group'], life['id']) and groups.get_leader(life, life['group']):
		if sight.can_see_target(life, groups.get_leader(life, life['group'])) and sight.can_see_target(LIFE[life_id], groups.get_leader(life, life['group'])):
			return False
	
	_disarm = brain.get_alife_flag(life, life_id, 'disarm')
	
	if _disarm:
		#For now...
		if not sight.can_see_position(life, LIFE[life_id]['pos']):
			groups.announce(life,
			                life['group'],
			                'attacked_by_hostile',
			                filter_if=lambda life_id: brain.knows_alife_by_id(life, life_id)['last_seen_time']<=30,
			                target_id=life_id)
			
			return False
		
		for item_uid in lfe.get_all_visible_items(LIFE[life_id]):
			if ITEMS[item_uid]['type'] == 'gun':
				break
		else:
			brain.unflag_alife(life, life_id, 'disarm')
			speech.start_dialog(life, life_id, 'clear_drop_weapon')
			
			return False
		
		_time_elapsed = WORLD_INFO['ticks']-_disarm
		
		if _time_elapsed>135 and not speech.has_sent(life, life_id, 'threaten'):
			speech.start_dialog(life, life_id, 'threaten')
			speech.send(life, life_id, 'threaten')
		elif _time_elapsed>185:
			speech.start_dialog(life, life_id, 'establish_hostile')
	elif not speech.has_sent(life, life_id, 'confront'):
		speech.start_dialog(life, life_id, 'confront')
		speech.send(life, life_id, 'confront')
Example #17
0
def search_for_target(life, target_id):
    # TODO: Variable size instead of hardcoded
    _know = brain.knows_alife_by_id(life, target_id)
    _size = 30
    _timer = brain.get_flag(life, "search_time")
    _chunk_path = alife.brain.get_flag(life, "chunk_path")

    if _chunk_path:
        travel_to_position(life, _chunk_path["end"], force=True)

        return False

    if _timer > 0:
        brain.flag(life, "search_time", _timer - 1)

        return False

    if brain.alife_has_flag(life, target_id, "search_map"):
        _search_map = brain.get_alife_flag(life, target_id, "search_map")
    else:
        _search_map = maps.create_search_map(life, _know["last_seen_at"], _size)
        brain.flag_alife(life, target_id, "search_map", value=_search_map)

        lfe.walk_to(life, _know["last_seen_at"])
        brain.flag(life, "search_time", 12)

        return False

    _lowest = {"score": -1, "pos": None}
    _x_top_left = numbers.clip(_know["last_seen_at"][0] - (_size / 2), 0, MAP_SIZE[0])
    _y_top_left = numbers.clip(_know["last_seen_at"][1] - (_size / 2), 0, MAP_SIZE[1])

    for x in range(0, _size):
        _x = _x_top_left + x

        if _x >= MAP_SIZE[0] - 1:
            continue

        for y in range(0, _size):
            _y = _y_top_left + y

            if _y >= MAP_SIZE[1] - 1:
                continue

            if not _search_map[y, x]:
                continue

            if sight.can_see_position(life, (_x, _y, _know["last_seen_at"][2]), get_path=True) or not lfe.can_walk_to(
                life, (_x, _y, _know["last_seen_at"][2])
            ):
                _search_map[y, x] = 0

            if _search_map[y, x] > 0 and (not _lowest["pos"] or _search_map[y, x] < _lowest["score"]):
                _lowest["score"] = _search_map[y, x]
                _lowest["pos"] = (_x, _y, x, y)

    if _lowest["pos"]:
        x, y, _x, _y = _lowest["pos"]

        if travel_to_position(life, (x, y, _know["last_seen_at"][2]), stop_on_sight=False):
            _search_map[_y, _x] = 0

        brain.flag(life, "search_time", numbers.clip(numbers.distance(life["pos"], (x, y)) * 0.75, 5, 16))
    else:
        _know["escaped"] = 2
Example #18
0
def search_for_target(life, target_id):
	#TODO: Variable size instead of hardcoded
	_know = brain.knows_alife_by_id(life, target_id)
	_size = 30
	_timer = brain.get_flag(life, 'search_time')
	_chunk_path = alife.brain.get_flag(life, 'chunk_path')
	
	if _chunk_path:
		travel_to_position(life, _chunk_path['end'], force=True)
		
		return False
	
	if _timer>0:
		brain.flag(life, 'search_time', _timer-1)
		
		return False
	
	if brain.alife_has_flag(life, target_id, 'search_map'):
		_search_map = brain.get_alife_flag(life, target_id, 'search_map')
	else:
		_search_map = maps.create_search_map(life, _know['last_seen_at'], _size)
		brain.flag_alife(life, target_id, 'search_map', value=_search_map)
		
		lfe.walk_to(life, _know['last_seen_at'])
		brain.flag(life, 'search_time', 12)
		
		return False
	
	_lowest = {'score': -1, 'pos': None}
	_x_top_left = bad_numbers.clip(_know['last_seen_at'][0]-(_size/2), 0, MAP_SIZE[0])
	_y_top_left = bad_numbers.clip(_know['last_seen_at'][1]-(_size/2), 0, MAP_SIZE[1])
	
	for x in range(0, _size):
		_x = _x_top_left+x
		
		if _x >= MAP_SIZE[0]-1:
			continue
		
		for y in range(0, _size):
			_y = _y_top_left+y
			
			if _y >= MAP_SIZE[1]-1:
				continue
			
			if not _search_map[y, x]:
				continue
			
			if sight.can_see_position(life, (_x, _y, _know['last_seen_at'][2]), get_path=True) or not lfe.can_walk_to(life, (_x, _y, _know['last_seen_at'][2])):
				_search_map[y, x] = 0
			
			if _search_map[y, x]>0 and (not _lowest['pos'] or _search_map[y, x] < _lowest['score']):
				_lowest['score'] = _search_map[y, x]
				_lowest['pos'] = (_x, _y, x, y)

	if _lowest['pos']:
		x, y, _x, _y = _lowest['pos']
		
		if travel_to_position(life, (x, y, _know['last_seen_at'][2]), stop_on_sight=False):
			_search_map[_y, _x] = 0
		
		brain.flag(life, 'search_time', bad_numbers.clip(bad_numbers.distance(life['pos'], (x, y))*.75, 5, 16))
	else:
		_know['escaped'] = 2
Example #19
0
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})
Example #20
0
def search_for_target(life, target_id):
    #TODO: Variable size instead of hardcoded
    _know = brain.knows_alife_by_id(life, target_id)
    _size = 30
    _timer = brain.get_flag(life, 'search_time')
    _chunk_path = alife.brain.get_flag(life, 'chunk_path')

    if _chunk_path:
        travel_to_position(life, _chunk_path['end'], force=True)

        return False

    if _timer > 0:
        brain.flag(life, 'search_time', _timer - 1)

        return False

    if brain.alife_has_flag(life, target_id, 'search_map'):
        _search_map = brain.get_alife_flag(life, target_id, 'search_map')
    else:
        _search_map = maps.create_search_map(life, _know['last_seen_at'],
                                             _size)
        brain.flag_alife(life, target_id, 'search_map', value=_search_map)

        lfe.walk_to(life, _know['last_seen_at'])
        brain.flag(life, 'search_time', 12)

        return False

    _lowest = {'score': -1, 'pos': None}
    _x_top_left = bad_numbers.clip(_know['last_seen_at'][0] - (_size / 2), 0,
                                   MAP_SIZE[0])
    _y_top_left = bad_numbers.clip(_know['last_seen_at'][1] - (_size / 2), 0,
                                   MAP_SIZE[1])

    for x in range(0, _size):
        _x = _x_top_left + x

        if _x >= MAP_SIZE[0] - 1:
            continue

        for y in range(0, _size):
            _y = _y_top_left + y

            if _y >= MAP_SIZE[1] - 1:
                continue

            if not _search_map[y, x]:
                continue

            if sight.can_see_position(life, (_x, _y, _know['last_seen_at'][2]),
                                      get_path=True) or not lfe.can_walk_to(
                                          life,
                                          (_x, _y, _know['last_seen_at'][2])):
                _search_map[y, x] = 0

            if _search_map[y, x] > 0 and (
                    not _lowest['pos']
                    or _search_map[y, x] < _lowest['score']):
                _lowest['score'] = _search_map[y, x]
                _lowest['pos'] = (_x, _y, x, y)

    if _lowest['pos']:
        x, y, _x, _y = _lowest['pos']

        if travel_to_position(life, (x, y, _know['last_seen_at'][2]),
                              stop_on_sight=False):
            _search_map[_y, _x] = 0

        brain.flag(
            life, 'search_time',
            bad_numbers.clip(
                bad_numbers.distance(life['pos'], (x, y)) * .75, 5, 16))
    else:
        _know['escaped'] = 2
Example #21
0
def prepare_for_raid(life, group_id):
	#_target_group = get_flag(life, group_id, 'raid_target')
	
	announce(life, group_id, 'combat_ready', ignore_if_said_in_last=1000,
	         filter_if=lambda alife_id: brain.get_alife_flag(life, LIFE[alife_id], 'combat_ready'))
Example #22
0
def create_function_map():
    FUNCTION_MAP.update(
        {
            "is_family": stats.is_family,
            "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_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,
            "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)["alignment"] == "hostile",
            "is_target_in_group": lambda life, life_id, **kwargs: 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)["group"] > 0,
            "is_target_group_friendly": lambda life, life_id: 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": lambda life, life_id: 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")
            == "hostile",
            "is_target_group_neutral": lambda life, life_id: 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",
            "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["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_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),
            "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_hide.tick(life),
            "search_for_threat": lambda life: alife_search.tick(life),
            "has_recoil": lambda life: life["recoil"] >= 4,
            "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"})[0]["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"]),
            "is_disarming": lambda life, life_id: brain.get_alife_flag(life, life_id, "disarm") > 0,
            "get_id": lambda life: life["id"],
            "always": lambda life: 1 == 1,
            "pass": lambda life, *a, **k: True,
            "never": lambda life: 1 == 2,
        }
    )