示例#1
0
def start_of_frame(draw_char_buffer=True):
    clear_view('overlay', color=tcod.Color(255, 0, 255))

    if not logic.draw_event() and SETTINGS['controlling']:
        _dialog = life.has_dialog(LIFE[SETTINGS['controlling']])
        if _dialog:
            dialog.draw_dialog(_dialog)

    draw_scene()
示例#2
0
def start_of_frame(draw_char_buffer=True):
	clear_view('overlay', color=tcod.Color(255, 0, 255))
	
	if not logic.draw_event() and SETTINGS['controlling']:
		_dialog = life.has_dialog(LIFE[SETTINGS['controlling']])
		if _dialog:
			dialog.draw_dialog(_dialog)	
	
	draw_scene()
示例#3
0
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 lfe.has_dialog(LIFE[SETTINGS['controlling']]):
			dialog.process(LIFE[SETTINGS['controlling']], lfe.has_dialog(LIFE[SETTINGS['controlling']]))
	
	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
示例#4
0
def can_tick(ignore_tickrate=False, ignore_pause=False):
    if SETTINGS['controlling'] and not EVENTS and not sum(
        [abs(i) for i in LIFE[SETTINGS['controlling']]['velocity']]):
        if life.is_target_of(LIFE[SETTINGS['controlling']]):
            if not SETTINGS['paused']:
                gfx.message('An enemy appears.', style='important')

            SETTINGS['paused'] = True

        if not ignore_pause and SETTINGS['paused'] and not LIFE[
                SETTINGS['controlling']]['actions'] and not LIFE[
                    SETTINGS['controlling']]['dead']:
            return False

    if not ignore_tickrate:
        if process_events():
            return False
    elif EVENTS and not ignore_pause:
        return False

    if SETTINGS['controlling'] and not ignore_pause and not sum(
        [abs(i) for i in LIFE[SETTINGS['controlling']]['velocity']]):
        if MENUS:
            return False

        if LIFE[SETTINGS['controlling']]['targeting']:
            return False

        if life.has_dialog(LIFE[SETTINGS['controlling']]):
            return False

    if not ignore_tickrate:
        if time.time() - WORLD_INFO['last_update_time'] < 1:
            if WORLD_INFO['tps'] < 30:
                WORLD_INFO['tps'] += 1
            else:
                return False
        else:
            WORLD_INFO['last_update_time'] = time.time()
            WORLD_INFO['tps'] = 0

    return True
示例#5
0
def can_tick(ignore_tickrate=False, ignore_pause=False):
	if SETTINGS['controlling'] and not EVENTS and not sum([abs(i) for i in LIFE[SETTINGS['controlling']]['velocity']]):
		if life.is_target_of(LIFE[SETTINGS['controlling']]):
			if not SETTINGS['paused']:
				gfx.message('An enemy appears.', style='important')
			
			SETTINGS['paused'] = True
			
		if not ignore_pause and SETTINGS['paused'] and not LIFE[SETTINGS['controlling']]['actions'] and not LIFE[SETTINGS['controlling']]['dead']:
			return False
	
	if not ignore_tickrate:
		if process_events():
			return False
	elif EVENTS and not ignore_pause:
		return False
	
	if SETTINGS['controlling'] and not ignore_pause and not sum([abs(i) for i in LIFE[SETTINGS['controlling']]['velocity']]):
		if MENUS:
			return False
		
		if LIFE[SETTINGS['controlling']]['targeting']:
			return False
	
		if life.has_dialog(LIFE[SETTINGS['controlling']]):
			return False
	
	if not ignore_tickrate: 
		if time.time()-WORLD_INFO['last_update_time']<1:
			if WORLD_INFO['tps']<30:
				WORLD_INFO['tps'] += 1
			else:
				return False
		else:
			WORLD_INFO['last_update_time'] = time.time()
			WORLD_INFO['tps'] = 0
	
	return True
示例#6
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']),
		'travel_to_chunk': movement.travel_to_chunk,
		'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: bad_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,
		'has_dialog': lambda life: lfe.has_dialog(life)>0,
		'is_in_territory': lambda life, territory_id: lfe.get_current_chunk_id(life) in WORLD_INFO['territories'][territory_id]['chunk_keys'],
		'capture_territory': lambda life, territory_id: factions.claim_existing_territory(life['faction'], territory_id),
		'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})
示例#7
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']),
        'travel_to_chunk':
        movement.travel_to_chunk,
        '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: bad_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,
        'has_dialog':
        lambda life: lfe.has_dialog(life) > 0,
        'is_in_territory':
        lambda life, territory_id: lfe.get_current_chunk_id(
            life) in WORLD_INFO['territories'][territory_id]['chunk_keys'],
        'capture_territory':
        lambda life, territory_id: factions.claim_existing_territory(
            life['faction'], territory_id),
        '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
    })