Esempio n. 1
0
def explosive(entity, x, y, tx, ty, speed, accuracy, damage):
    _entity = _create(x, y, 'Explosive', '.', 0, 'bullet')
    _entity['owner'] = entity['_id']
    _entity['start_position'] = (x, y)
    _entity['end_position'] = (tx, ty)
    _entity['speed'] = speed
    _entity['damage'] = damage
    _toss_distance = numbers.distance(_entity['start_position'],
                                      _entity['end_position'])
    _entity['accuracy'] = numbers.clip(
        random.randint(int(round(accuracy * .25)), accuracy), 0,
        100) - (accuracy * (1 - (_toss_distance / 20.0)))
    _entity['slow_down'] = False
    _direction_mod = random.uniform(-accuracy, accuracy) * 2

    entities.create_event(_entity, 'explode')
    entities.create_event(_entity, 'activate_explosive')
    entities.register_event(_entity, 'explode', frag_grenade_explode)
    entities.register_event(_entity, 'explode', entities.delete_entity)
    entities.register_event(
        _entity, 'activate_explosive', lambda e: entities.trigger_event(
            e,
            'create_timer',
            time=90,
            exit_callback=lambda ee: entities.trigger_event(ee, 'explode')))
    entities.register_event(_entity, 'check_next_position',
                            check_next_position)

    entities.add_entity_to_group(_entity, 'bullets')
    timers.register(_entity)

    entities.trigger_event(_entity,
                           'set_direction',
                           direction=numbers.direction_to(
                               (x, y), (tx, ty)) + _direction_mod)
    entities.trigger_event(_entity,
                           'create_timer',
                           time=speed,
                           enter_callback=_explosive_tick,
                           name='movement')
    entities.register_event(_entity, 'position_changed',
                            lambda e, **kwargs: check_for_collisions(e))

    if not '--no-fx' in sys.argv:
        entities.register_event(
            _entity, 'position_changed',
            lambda e, x, y, **kwargs: _bullet_effects(e, x, y))

    entities.register_event(
        _entity, 'collision_with_entity',
        lambda e, **kwargs: entities.trigger_event(e, 'activate_explosive'))
    entities.register_event(_entity, 'collision_with_entity',
                            lambda e, **kwargs: _explosive_stop_dumb_hack(e))
    entities.register_event(_entity, 'collision_with_solid',
                            lambda e: timers.stop_timer(e, 'movement'))
    entities.register_event(_entity, 'collision_with_solid',
                            _explosive_stop_dumb_hack)
    entities.register_event(
        _entity, 'collision_with_solid',
        lambda e: entities.trigger_event(e, 'activate_explosive'))
Esempio n. 2
0
def explosive(entity, x, y, tx, ty, speed, accuracy, damage):
	_entity = _create(x, y, 'Explosive', '.', 0, 'bullet')
	_entity['owner'] = entity['_id']
	_entity['start_position'] = (x, y)
	_entity['end_position'] = (tx, ty)
	_entity['speed'] = speed
	_entity['damage'] = damage
	_toss_distance = numbers.distance(_entity['start_position'], _entity['end_position'])
	_entity['accuracy'] = numbers.clip(random.randint(int(round(accuracy * .25)), accuracy), 0, 100) - (accuracy * (1 - (_toss_distance / 20.0)))
	_entity['slow_down'] = False
	_direction_mod = random.uniform(-accuracy, accuracy) * 2
	
	entities.create_event(_entity, 'explode')
	entities.create_event(_entity, 'activate_explosive')
	entities.register_event(_entity, 'explode', frag_grenade_explode)
	entities.register_event(_entity, 'explode', entities.delete_entity)
	entities.register_event(_entity, 'activate_explosive', lambda e: entities.trigger_event(e, 'create_timer', time=90, exit_callback=lambda ee: entities.trigger_event(ee, 'explode')))
	entities.register_event(_entity, 'check_next_position', check_next_position)
	
	entities.add_entity_to_group(_entity, 'bullets')
	timers.register(_entity)
	
	entities.trigger_event(_entity, 'set_direction', direction=numbers.direction_to((x, y), (tx, ty)) + _direction_mod)
	entities.trigger_event(_entity, 'create_timer', time=speed, enter_callback=_explosive_tick, name='movement')
	entities.register_event(_entity, 'position_changed', lambda e, **kwargs: check_for_collisions(e))
	
	if not '--no-fx' in sys.argv:
		entities.register_event(_entity, 'position_changed', lambda e, x, y, **kwargs: _bullet_effects(e, x, y))
	
	entities.register_event(_entity, 'collision_with_entity', lambda e, **kwargs: entities.trigger_event(e, 'activate_explosive'))
	entities.register_event(_entity, 'collision_with_entity', lambda e, **kwargs: _explosive_stop_dumb_hack(e))
	entities.register_event(_entity, 'collision_with_solid', lambda e: timers.stop_timer(e, 'movement'))
	entities.register_event(_entity, 'collision_with_solid', _explosive_stop_dumb_hack)
	entities.register_event(_entity, 'collision_with_solid', lambda e: entities.trigger_event(e, 'activate_explosive'))
Esempio n. 3
0
def message(text, fore_color=(255, 255, 255), back_color=(10, 10, 10), time=-1, center=False, vert_center=False):
	global MESSAGES_ACTIVE
	
	_entity = entities.create_entity(group='ui_effects_freetick')
	
	if time == -1:
		_time = 30 * constants.SHOW_MESSAGES_FOR
	
	else:
		_time = time
	
	timers.register(_entity, use_system_event='draw')
	flags.register(_entity)
	
	entities.create_event(_entity, 'draw')
	entities.register_event(_entity, 'draw', _message_draw)
	entities.register_event(_entity, 'delete', _message_delete)
	entities.trigger_event(_entity, 'create_timer', time=_time, exit_callback=entities.delete_entity)
	entities.trigger_event(_entity, 'set_flag', flag='text', value=text)
	entities.trigger_event(_entity, 'set_flag', flag='index', value=MESSAGES_ACTIVE)
	entities.trigger_event(_entity, 'set_flag', flag='center', value=center)
	entities.trigger_event(_entity, 'set_flag', flag='vert_center', value=vert_center)
	
	MESSAGES_ACTIVE += 1
	
	return _entity
Esempio n. 4
0
def create(x, y, title=None, surface='ui_menus', click_offset=(0, 0)):
    global ACTIVE_MENU

    _entity = entities.create_entity(group='ui_menus')
    _entity.update({
        'items': {},
        'active': True,
        'index': 0,
        'item_id': 0,
        'surface': surface,
        'click_offset': click_offset,
        'x': x,
        'y': y
    })

    entities.create_event(_entity, 'reactivated')

    if title:
        add_title(_entity, title)

        _entity['index'] = 1

    ACTIVE_MENU = _entity

    return _entity
Esempio n. 5
0
def printer(x, y, text, center=True, fore_color=(255, 255, 255), moving=True, move_direction=90, back_color=(10, 10, 10), speed_mod=1.0, show_mod=1.0, free_tick=True):
	if '--no-fx' in sys.argv:
		return
	
	_entity = entities.create_entity(group='ui_effects' + ('_freetick' * free_tick))
	
	timers.register(_entity)
	flags.register(_entity)
	
	entities.create_event(_entity, 'draw')
	entities.register_event(_entity, 'draw', _printer_draw)
	entities.trigger_event(_entity, 'set_flag', flag='text', value=text)
	entities.trigger_event(_entity, 'set_flag', flag='text_index', value=0)
	entities.trigger_event(_entity, 'set_flag', flag='text_center', value=center)
	entities.trigger_event(_entity, 'set_flag', flag='text_pos', value=(x, y))
	entities.trigger_event(_entity, 'set_flag', flag='text_orig_pos', value=(x, y))
	entities.trigger_event(_entity, 'set_flag', flag='text_fore_color', value=fore_color)
	entities.trigger_event(_entity, 'set_flag', flag='text_back_color', value=back_color)
	entities.trigger_event(_entity, 'set_flag', flag='move_direction', value=move_direction)
	entities.trigger_event(_entity, 'create_timer', time=12*speed_mod, repeat=len(text), repeat_callback=_printer_tick)
	entities.trigger_event(_entity, 'create_timer', time=((10*speed_mod)*len(text))+(60*show_mod), exit_callback=_printer_exit)
	
	if moving:
		entities.trigger_event(_entity, 'create_timer', time=25, repeat=len(text)/2, repeat_callback=_printer_move)
	
	return _entity
Esempio n. 6
0
def create(title, briefing=''):
    _mission = entities.create_entity(group='missions')
    _mission.update({
        'title': title,
        'goals': [],
        'members': [],
        'member_memory': {},  #Unused
        'briefing': briefing
    })

    entities.create_event(_mission, 'member_added')
    entities.create_event(_mission, 'remove_member')
    entities.create_event(_mission, 'get_details')
    entities.create_event(_mission, 'get_briefing')
    entities.create_event(_mission, 'complete')
    entities.register_event(_mission, 'member_added', member_added)
    entities.register_event(_mission, 'remove_member', remove_member)
    entities.register_event(_mission, 'logic', logic)
    entities.register_event(_mission, 'get_details', get_mission_details)
    entities.register_event(_mission, 'get_briefing', get_mission_briefing)
    entities.register_event(_mission, 'complete', complete_mission)

    logging.info('Creating mission: %s' % _mission['_id'])

    return _mission
Esempio n. 7
0
def register_with_squad(entity, squad_id):
	entity['ai']['squad'] = squad_id
	
	_squad = get_assigned_squad(entity)
	
	_squad['members'].add(entity['_id'])
	_squad['member_position_maps'][entity['_id']] = set()
	
	if not _squad['leader']:
		_squad['leader'] = entity['_id']
	
	entity['ai']['meta']['is_squad_leader'] = _squad['leader'] == entity['_id']
	
	entities.create_event(entity, 'squad_inform_raid')
	entities.register_event(_squad, 'meta_change', lambda e, **kwargs: entities.trigger_event(entity, 'set_meta', **kwargs))
	#entities.register_event(entity, 'position_changed', lambda e, **kwargs: _squad['_id'] in entities.ENTITIES and entities.trigger_event(_squad, 'update_position_map', member_id=entity['_id']))
	entities.register_event(entity, 'meta_change', lambda e, **kwargs: update_squad_member_snapshot(_squad, target_id=e['_id']))
	entities.register_event(entity, 'meta_change', lambda e, **kwargs: update_group_status(_squad)) #TODO: Needs to be moved to a general area. Are squad members registering this?
	entities.register_event(entity, 'target_lost', ai_squad_logic.leader_handle_lost_target)
	entities.register_event(entity, 'target_lost', lambda e, **kwargs: update_combat_risk)
	entities.register_event(entity, 'target_found', lambda e, **kwargs: update_combat_risk)
	entities.register_event(entity, 'squad_inform_raid', ai_squad_logic.member_learn_raid)
	entities.register_event(entity,
	                        'killed_by',
	                        lambda e, target_id, **kwargs: remove_member(_squad, entity['_id']))
	
	entities.trigger_event(_squad, 'new_squad_member', target_id=entity['_id'])
Esempio n. 8
0
def _create():
	_entity = entities.create_entity(group='systems')
	
	#timers.register(_entity)
	
	entities.create_event(_entity, 'finish')
	
	return _entity
Esempio n. 9
0
def boot():
    global FLOW

    _entity = entities.create_entity()

    entities.create_event(_entity, 'start_of_turn')
    entities.create_event(_entity, 'end_of_turn')

    FLOW = _entity
Esempio n. 10
0
def boot():
	global FLOW
	
	_entity = entities.create_entity()
	
	entities.create_event(_entity, 'start_of_turn')
	entities.create_event(_entity, 'end_of_turn')
	
	FLOW = _entity
Esempio n. 11
0
def register(entity):
    entity['inventory'] = {'items': [], 'holders': {}, 'containers': {}}

    entities.create_event(entity, 'give_item')
    entities.register_event(entity, 'give_item', give_item)
    entities.create_event(entity, 'disown_item')
    entities.register_event(entity, 'disown_item', disown_item)
    entities.create_event(entity, 'store_item')
    entities.register_event(entity, 'store_item', store_item)
    entities.create_event(entity, 'hold_item')
    entities.register_event(entity, 'hold_item', hold_item)
    entities.create_event(entity, 'create_holder')
    entities.register_event(entity, 'create_holder', add_holder)
Esempio n. 12
0
def _create_squad(faction_name, x, y):
    _faction = FACTIONS[faction_name]
    _squad = entities.create_entity(group='squads')
    _squad.update({
        'members': set(),
        'faction': faction_name,
        'leader': None,
        'member_info': {},
        'camp_id': None,
        'squad_id': _faction['squad_id'],
        'task': None,
        'brain': None,
        'position_map': {},
        'member_position_maps': {},
        'member_los_maps': {},
        'coverage_positions': set(),
        'known_targets': set(),
        'known_squads': set(),
        'position_map_scores': {},
        'meta': {
            'is_squad_combat_ready': False,
            'is_squad_mobile_ready': False,
            'is_squad_overwhelmed': False,
            'is_squad_forcing_surrender': False,
            'has_camp': False,
            'wants_artifacts': False,
            'wants_weapons': False
        },
        'weights': {}
    })

    timers.register(_squad, use_entity_event='logic')
    movement.register(_squad, x, y)

    entities.create_event(_squad, 'meta_change')
    entities.create_event(_squad, 'raid')
    entities.create_event(_squad, 'update_position_map')
    entities.create_event(_squad, 'new_squad_member')
    entities.register_event(_squad, 'raid', handle_raid)
    entities.register_event(_squad, 'update_position_map',
                            ai_squad_director.create_position_map)

    _faction['squads'][_faction['squad_id']] = _squad['_id']
    #entity['ai']['meta']['is_squad_leader'] = True

    #register_with_squad(entity, _faction['squad_id'])

    _faction['squad_id'] += 1

    entities.register_event(_squad, 'new_squad_member',
                            update_squad_member_snapshot)
    entities.register_event(_squad, 'new_squad_member',
                            lambda e, **kwargs: update_group_status(e))
    entities.register_event(
        ai_flow.FLOW, 'start_of_turn',
        lambda e, squad_id: handle_start_of_turn(_squad, squad_id))

    logging.info('Faction \'%s\' created new squad.' % faction_name)

    return _squad
Esempio n. 13
0
def register(entity):
	entity['inventory'] = {'items': [],
	                       'holders': {},
	                       'containers': {}}
	
	entities.create_event(entity, 'give_item')
	entities.register_event(entity, 'give_item', give_item)
	entities.create_event(entity, 'disown_item')
	entities.register_event(entity, 'disown_item', disown_item)
	entities.create_event(entity, 'store_item')
	entities.register_event(entity, 'store_item', store_item)
	entities.create_event(entity, 'hold_item')
	entities.register_event(entity, 'hold_item', hold_item)
	entities.create_event(entity, 'create_holder')
	entities.register_event(entity, 'create_holder', add_holder)
Esempio n. 14
0
def create(x, y, text, buttons=None, title='Dialog'):
	global ACTIVE_DIALOG
	
	if '--no-fx' in sys.argv:
		return
	
	_entity = entities.create_entity(group='ui_dialogs')
	_entity.update({'text': text,
	                'title': title,
	                'buttons': buttons,
	                'x': x,
	                'y': y})
	
	entities.create_event(_entity, 'reactivated')
	
	ACTIVE_DIALOG = _entity
	
	return _entity
Esempio n. 15
0
def create(x, y, text, buttons=None, title='Dialog'):
    global ACTIVE_DIALOG

    if '--no-fx' in sys.argv:
        return

    _entity = entities.create_entity(group='ui_dialogs')
    _entity.update({
        'text': text,
        'title': title,
        'buttons': buttons,
        'x': x,
        'y': y
    })

    entities.create_event(_entity, 'reactivated')

    ACTIVE_DIALOG = _entity

    return _entity
Esempio n. 16
0
def _create_squad(faction_name, x, y):
	_faction = FACTIONS[faction_name]
	_squad = entities.create_entity(group='squads')
	_squad.update({'members': set(),
	               'faction': faction_name,
	               'leader': None,
	               'member_info': {},
	               'camp_id': None,
	               'squad_id': _faction['squad_id'],
	               'task': None,
	               'brain': None,
	               'position_map': {},
	               'member_position_maps': {},
	               'member_los_maps': {},
	               'coverage_positions': set(),
	               'known_targets': set(),
	               'known_squads': set(),
	               'position_map_scores': {},
	               'meta': {'is_squad_combat_ready': False,
	                        'is_squad_mobile_ready': False,
	                        'is_squad_overwhelmed': False,
	                        'is_squad_forcing_surrender': False,
	                        'has_camp': False,
	                        'wants_artifacts': False,
	                        'wants_weapons': False},
	               'weights': {}})
	
	timers.register(_squad, use_entity_event='logic')
	movement.register(_squad, x, y)
	
	entities.create_event(_squad, 'meta_change')
	entities.create_event(_squad, 'raid')
	entities.create_event(_squad, 'update_position_map')
	entities.create_event(_squad, 'new_squad_member')
	entities.register_event(_squad, 'raid', handle_raid)
	entities.register_event(_squad, 'update_position_map', ai_squad_director.create_position_map)
	
	_faction['squads'][_faction['squad_id']] = _squad['_id']
	#entity['ai']['meta']['is_squad_leader'] = True
	
	#register_with_squad(entity, _faction['squad_id'])
	
	_faction['squad_id'] += 1
	
	entities.register_event(_squad, 'new_squad_member', update_squad_member_snapshot)
	entities.register_event(_squad, 'new_squad_member', lambda e, **kwargs: update_group_status(e))
	entities.register_event(ai_flow.FLOW, 'start_of_turn', lambda e, squad_id: handle_start_of_turn(_squad, squad_id))
	
	logging.info('Faction \'%s\' created new squad.' % faction_name)
	
	return _squad
Esempio n. 17
0
def create_goal(mission,
                intent,
                message,
                logic_callback,
                message_callback,
                draw=True,
                details=[],
                **kwargs):
    _goal = entities.create_entity()

    _goal['intent'] = intent
    _goal['mission_id'] = mission['_id']
    _goal['message'] = message
    _goal['draw'] = draw
    _goal['details'] = details
    _goal.update(kwargs)

    entities.create_event(_goal, 'get_message')
    entities.create_event(_goal, 'member_added')
    entities.create_event(_goal, 'add_goal_cleanup_event')
    entities.register_event(_goal, 'logic', logic_callback)
    entities.register_event(_goal, 'get_message', message_callback)
    entities.register_event(_goal, 'add_goal_cleanup_event',
                            add_goal_cleanup_event)

    mission['goals'].append(_goal['_id'])

    logging.info('Creating goal \'%s\' for mission %s: %s' %
                 (intent, mission['_id'], kwargs))

    return _goal
Esempio n. 18
0
def register_with_squad(entity, squad_id):
    entity['ai']['squad'] = squad_id

    _squad = get_assigned_squad(entity)

    _squad['members'].add(entity['_id'])
    _squad['member_position_maps'][entity['_id']] = set()

    if not _squad['leader']:
        _squad['leader'] = entity['_id']

    entity['ai']['meta']['is_squad_leader'] = _squad['leader'] == entity['_id']

    entities.create_event(entity, 'squad_inform_raid')
    entities.register_event(
        _squad, 'meta_change', lambda e, **kwargs: entities.trigger_event(
            entity, 'set_meta', **kwargs))
    #entities.register_event(entity, 'position_changed', lambda e, **kwargs: _squad['_id'] in entities.ENTITIES and entities.trigger_event(_squad, 'update_position_map', member_id=entity['_id']))
    entities.register_event(
        entity, 'meta_change',
        lambda e, **kwargs: update_squad_member_snapshot(_squad,
                                                         target_id=e['_id']))
    entities.register_event(
        entity, 'meta_change', lambda e, **kwargs: update_group_status(_squad)
    )  #TODO: Needs to be moved to a general area. Are squad members registering this?
    entities.register_event(entity, 'target_lost',
                            ai_squad_logic.leader_handle_lost_target)
    entities.register_event(entity, 'target_lost',
                            lambda e, **kwargs: update_combat_risk)
    entities.register_event(entity, 'target_found',
                            lambda e, **kwargs: update_combat_risk)
    entities.register_event(entity, 'squad_inform_raid',
                            ai_squad_logic.member_learn_raid)
    entities.register_event(
        entity, 'killed_by',
        lambda e, target_id, **kwargs: remove_member(_squad, entity['_id']))

    entities.trigger_event(_squad, 'new_squad_member', target_id=entity['_id'])
Esempio n. 19
0
def create(x, y, title=None, surface='ui_menus', click_offset=(0, 0)):
	global ACTIVE_MENU
	
	_entity = entities.create_entity(group='ui_menus')
	_entity.update({'items': {},
	                'active': True,
	                'index': 0,
	                'item_id': 0,
	                'surface': surface,
	                'click_offset': click_offset,
	                'x': x,
	                'y': y})
	
	entities.create_event(_entity, 'reactivated')
	
	if title:
		add_title(_entity, title)
		
		_entity['index'] = 1
	
	ACTIVE_MENU = _entity
	
	return _entity
Esempio n. 20
0
def create(title, briefing=''):
	_mission = entities.create_entity(group='missions')
	_mission.update({'title': title,
	                 'goals': [],
	                 'members': [],
	                 'member_memory': {},  #Unused
	                 'briefing': briefing})
	
	entities.create_event(_mission, 'member_added')
	entities.create_event(_mission, 'remove_member')
	entities.create_event(_mission, 'get_details')
	entities.create_event(_mission, 'get_briefing')
	entities.create_event(_mission, 'complete')
	entities.register_event(_mission, 'member_added', member_added)
	entities.register_event(_mission, 'remove_member', remove_member)
	entities.register_event(_mission, 'logic', logic)
	entities.register_event(_mission, 'get_details', get_mission_details)
	entities.register_event(_mission, 'get_briefing', get_mission_briefing)
	entities.register_event(_mission, 'complete', complete_mission)
	
	logging.info('Creating mission: %s' % _mission['_id'])
	
	return _mission
Esempio n. 21
0
def register(entity):
    entity['missions'] = {'active': {}, 'inactive': {}, 'complete': []}

    entities.create_event(entity, 'add_mission')
    entities.create_event(entity, 'complete_mission')
    entities.create_event(entity, 'complete_goal')
    entities.create_event(entity, 'uncomplete_goal')
    entities.register_event(entity, 'complete_goal', complete_goal)
    entities.register_event(entity, 'uncomplete_goal', uncomplete_goal)
    entities.register_event(entity, 'add_mission', add_mission)
    entities.register_event(entity, 'complete_mission',
                            member_complete_mission)
    entities.register_event(
        entity, 'complete_mission', lambda e, mission_id: entities.
        trigger_event(entities.get_entity(mission_id),
                      'remove_member',
                      target_id=e['_id']))
Esempio n. 22
0
def register(entity):
	entity['missions'] = {'active': {},
	                      'inactive': {},
	                      'complete': []}
	
	entities.create_event(entity, 'add_mission')
	entities.create_event(entity, 'complete_mission')
	entities.create_event(entity, 'complete_goal')
	entities.create_event(entity, 'uncomplete_goal')
	entities.register_event(entity, 'complete_goal', complete_goal)
	entities.register_event(entity, 'uncomplete_goal', uncomplete_goal)
	entities.register_event(entity, 'add_mission', add_mission)
	entities.register_event(entity, 'complete_mission', member_complete_mission)
	entities.register_event(entity,
	                        'complete_mission',
	                        lambda e, mission_id: entities.trigger_event(entities.get_entity(mission_id),
	                                                                     'remove_member',
	                                                                     target_id=e['_id']))
Esempio n. 23
0
def register(entity):
    entity['skeleton'] = {'limbs': {}, 'motions': {}, 'motion': None}

    entities.create_event(entity, 'hit')
    entities.create_event(entity, 'force')
    entities.create_event(entity, 'set_motion')
    entities.register_event(entity, 'hit', hit)
    entities.register_event(entity, 'force', force)
    entities.register_event(entity, 'get_mobility', get_mobility_mod)
    entities.register_event(entity, 'get_accuracy', get_accuracy_mod)
    entities.register_event(entity, 'get_vision', get_vision_mod)
    entities.register_event(entity, 'set_motion', set_motion)
    entities.register_event(entity, 'damage', handle_pain)
    entities.register_event(entity, 'tick', tick)

    return entity
Esempio n. 24
0
def _create(name, squad_size_range, base_size_range, enemy_factions):
    _entity = entities.create_entity(group='factions')
    _faction = {
        'members': set(),
        'squads': {},
        'squad_id': 1,
        'faction_memory': {},
        'brains': [],
        'meta': {},
        'money': 1200,
        'squad_size_range': squad_size_range,
        'base_size_range': base_size_range,
        'enemies': enemy_factions,
        'relations': {}
    }

    for faction_name in FACTIONS:
        _other_faction = FACTIONS[faction_name]

        if name in _other_faction['enemies']:
            _other_score = 0
        else:
            _other_score = 25

        if faction_name in enemy_factions:
            _score = 0
        else:
            _score = 25

        _other_faction['relations'][name] = _other_score
        _faction['relations'][faction_name] = _score
        _faction['faction_memory'][faction_name] = {'squads': {}}
        _other_faction['faction_memory'][name] = {'squads': {}}

    _entity.update(_faction)

    entities.create_event(_entity, 'add_member')
    entities.create_event(_entity, 'faction_raid_incoming')
    entities.create_event(_entity, 'broadcast')
    entities.register_event(_entity, 'add_member', add_member)
    entities.register_event(_entity, 'broadcast', handle_broadcast)
    entities.register_event(_entity, 'faction_raid_incoming',
                            handle_raid_incoming)

    FACTIONS[name] = _entity

    return _entity
Esempio n. 25
0
def _create(name, squad_size_range, base_size_range, enemy_factions):
	_entity = entities.create_entity(group='factions')
	_faction = {'members': set(),
	            'squads': {},
	            'squad_id': 1,
	            'faction_memory': {},
	            'brains': [],
	            'meta': {},
	            'money': 1200,
	            'squad_size_range': squad_size_range,
	            'base_size_range': base_size_range,
	            'enemies': enemy_factions,
	            'relations': {}}
	
	for faction_name in FACTIONS:
		_other_faction = FACTIONS[faction_name]
		
		if name in _other_faction['enemies']:
			_other_score = 0
		else:
			_other_score = 25
		
		if faction_name in enemy_factions:
			_score = 0
		else:
			_score = 25
		
		_other_faction['relations'][name] = _other_score
		_faction['relations'][faction_name] = _score
		_faction['faction_memory'][faction_name] = {'squads': {}}
		_other_faction['faction_memory'][name] = {'squads': {}}
	
	_entity.update(_faction)
	
	entities.create_event(_entity, 'add_member')
	entities.create_event(_entity, 'faction_raid_incoming')
	entities.create_event(_entity, 'broadcast')
	entities.register_event(_entity, 'add_member', add_member)
	entities.register_event(_entity, 'broadcast', handle_broadcast)
	entities.register_event(_entity, 'faction_raid_incoming', handle_raid_incoming)
	
	FACTIONS[name] = _entity
	
	return _entity
Esempio n. 26
0
def create_goal(mission, intent, message, logic_callback, message_callback, draw=True, details=[], **kwargs):
	_goal = entities.create_entity()
	
	_goal['intent'] = intent
	_goal['mission_id'] = mission['_id']
	_goal['message'] = message
	_goal['draw'] = draw
	_goal['details'] = details
	_goal.update(kwargs)
	
	entities.create_event(_goal, 'get_message')
	entities.create_event(_goal, 'member_added')
	entities.create_event(_goal, 'add_goal_cleanup_event')
	entities.register_event(_goal, 'logic', logic_callback)
	entities.register_event(_goal, 'get_message', message_callback)
	entities.register_event(_goal, 'add_goal_cleanup_event', add_goal_cleanup_event)
	
	mission['goals'].append(_goal['_id'])
	
	logging.info('Creating goal \'%s\' for mission %s: %s' % (intent, mission['_id'], kwargs))
	
	return _goal
Esempio n. 27
0
def register(entity):
    entities.create_event(entity, 'create_noise')
    entities.create_event(entity, 'heard_noise')
    entities.register_event(entity, 'create_noise', create_noise)

    return entity
Esempio n. 28
0
def _create_animal(x, y, health, speed, name, vision=65, faction='Mutants', has_ai=False, char='m', fore_color=(255, 255, 255)):
	_entity = entities.create_entity(group='life')
	
	entities.create_event(_entity, 'damage')
	entities.create_event(_entity, 'did_damage')
	entities.create_event(_entity, 'receive_memory')
	entities.create_event(_entity, 'handle_corpse')
	entities.create_event(_entity, 'finish_turn')

	tile.register(_entity, surface='life', char=char, fore_color=fore_color)
	movement.register(_entity, collisions=True)
	timers.register(_entity)
	stats.register(_entity, health, speed, vision, name=name, kind='animal')
	nodes.register(_entity)
	items.register(_entity)
	flags.register(_entity)
	noise.register(_entity)
	skeleton.register(_entity)
	ai_factions.register(_entity, faction)

	if has_ai:
		ai.register_animal(_entity)
	
	_entity['ai']['is_npc'] = True

	entities.register_event(_entity, 'finish_turn', finish_turn)
	entities.create_event(_entity, 'get_and_store_item')
	entities.create_event(_entity, 'get_and_hold_item')
	entities.create_event(_entity, 'reload')
	entities.create_event(_entity, 'shoot')
	entities.create_event(_entity, 'damage')
	entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
	entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
	entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
	entities.register_event(_entity, 'reload', reload_weapon)
	entities.register_event(_entity, 'shoot', shoot_weapon)
	entities.register_event(_entity, 'heard_noise', handle_heard_noise)
	entities.register_event(_entity, 'position_changed',
	                        lambda e, **kwargs: entities.trigger_event(e,
	                                                                   'create_noise',
	                                                                   volume=25,
	                                                                   text='?',
	                                                                   owner_can_hear=False,
	                                                                   callback=lambda t, x, y: entities.trigger_event(t,
	                                                                                                            'update_target_memory',
	                                                                                                            target_id=_entity['_id'],
	                                                                                                            key='last_seen_at',
	                                                                                                            value=[x, y])))
	#entities.register_event(_entity, 'position_changed', lambda e, **kwargs: ai_visuals.add_to_moved_life(e))
	entities.register_event(_entity, 'push', lambda e, **kwargs: movement.sub_move_cost(e))
	                        
	entities.trigger_event(_entity, 'set_position', x=x, y=y)
	entities.trigger_event(_entity, 'create_holder', name='weapon', max_weight=10)
	entities.trigger_event(_entity, 'create_holder', name='backpack', max_weight=10)

	return _entity
Esempio n. 29
0
def _register(entity, player=False):
    ONLINE_ENTITIES.append(entity["_id"])

    entity["ai"] = {
        "brain": goapy.World(),
        "brain_offline": goapy.World(),
        "current_action": "idle",
        "last_action": "idle",
        "visible_items": {},
        "visible_life": set(),
        "visible_targets": [],
        "targets_to_search": [],
        "targets": set(),
        "nearest_target": None,
        "life_memory": {},
        "is_player": player,
        "is_npc": False,
        "meta": {
            "is_injured": False,
            "is_panicked": False,
            "is_squad_combat_ready": False,
            "is_squad_overwhelmed": False,
            "is_squad_forcing_surrender": False,
            "is_squad_mobile_ready": False,
            "is_squad_leader": False,
            "has_bandage": False,
            "has_ammo": False,
            "has_weapon": False,
            "has_container": False,
            "has_firing_position": False,
            "has_lost_target": False,
            "weapon_loaded": False,
            "in_engagement": False,
            "is_target_near": False,
            "is_target_armed": False,
            "in_cover": False,
            "in_enemy_los": False,
            "in_firing_range": False,
            "is_hungry": False,
            "has_food": False,
            "sees_item_type_weapon": False,
            "sees_item_type_container": False,
            "sees_item_type_ammo": False,
            "has_needs": False,
        },
        "weights": {"find_bandage": 10, "find_weapon": 16, "find_container": 14, "track": 20},
    }

    entities.create_event(entity, "logic_offline")
    entities.create_event(entity, "update_target_memory")
    entities.create_event(entity, "meta_change")
    entities.create_event(entity, "set_meta")
    entities.create_event(entity, "has_needs")
    entities.create_event(entity, "new_target_spotted")
    entities.create_event(entity, "broadcast")
    entities.create_event(entity, "target_lost")
    entities.create_event(entity, "target_found")
    entities.create_event(entity, "target_search_failed")
    entities.create_event(entity, "squad_inform_lost_target")
    entities.create_event(entity, "squad_inform_found_target")
    entities.create_event(entity, "squad_inform_failed_search")
    entities.register_event(entity, "save", save)
    entities.register_event(entity, "delete", _cleanup)
    entities.register_event(entity, "set_meta", set_meta)
    entities.register_event(entity, "update_target_memory", update_target_memory)
    entities.register_event(entity, "target_lost", ai_squad_logic.member_handle_lost_target)
    entities.register_event(entity, "target_found", ai_squad_logic.member_handle_found_target)
    entities.register_event(entity, "target_search_failed", ai_squad_logic.member_handle_failed_target_search)
    entities.register_event(entity, "squad_inform_lost_target", ai_squad_logic.member_learn_lost_target)
    entities.register_event(entity, "squad_inform_found_target", ai_squad_logic.member_learn_found_target)
    entities.register_event(entity, "squad_inform_failed_search", ai_squad_logic.member_learn_failed_target_search)
Esempio n. 30
0
def register(entity,
             active=True,
             clipping=True,
             ignore_groups=[],
             ignore_entities=[]):
    _collidable = {
        'active': active,
        'x': 5,
        'y': 5,
        'last_x': 5,
        'last_y': 5,
        'ignore_groups': ignore_groups,
        'ignore_entities': ignore_entities,
        'clipping': clipping
    }

    entity['collidable'] = _collidable

    entities.create_event(entity, 'set_collidable')
    entities.create_event(entity, 'set_not_collidable')
    entities.create_event(entity, 'set_position')
    entities.create_event(entity, 'position_changed')
    entities.create_event(entity, 'collision_with_entity')
    entities.create_event(entity, 'allow_clipping')
    entities.create_event(entity, 'ban_clipping')
    entities.register_event(entity, 'allow_clipping', _allow_clipping)
    entities.register_event(entity, 'ban_clipping', _ban_clipping)
    entities.register_event(entity, 'delete', delete)
    entities.register_event(entity, 'set_collidable', set_active)
    entities.register_event(entity, 'set_not_collidable', set_inactive)
    entities.register_event(entity, 'set_position', set_collidable_position)
    entities.register_event(entity, 'position_changed', handle_collisions)
Esempio n. 31
0
def register(entity, active=True, clipping=True, ignore_groups=[], ignore_entities=[]):
	_collidable = {'active': active,
	               'x': 5,
	               'y': 5,
	               'last_x': 5,
	               'last_y': 5,
	               'ignore_groups': ignore_groups,
	               'ignore_entities': ignore_entities,
	               'clipping': clipping}
	
	entity['collidable'] = _collidable
	
	entities.create_event(entity, 'set_collidable')
	entities.create_event(entity, 'set_not_collidable')
	entities.create_event(entity, 'set_position')
	entities.create_event(entity, 'position_changed')
	entities.create_event(entity, 'collision_with_entity')
	entities.create_event(entity, 'allow_clipping')
	entities.create_event(entity, 'ban_clipping')
	entities.register_event(entity, 'allow_clipping', _allow_clipping)
	entities.register_event(entity, 'ban_clipping', _ban_clipping)
	entities.register_event(entity, 'delete', delete)
	entities.register_event(entity, 'set_collidable', set_active)
	entities.register_event(entity, 'set_not_collidable', set_inactive)
	entities.register_event(entity, 'set_position', set_collidable_position)
	entities.register_event(entity, 'position_changed', handle_collisions)
Esempio n. 32
0
def register(entity):
	entities.create_event(entity, 'create_noise')
	entities.create_event(entity, 'heard_noise')
	entities.register_event(entity, 'create_noise', create_noise)

	return entity
Esempio n. 33
0
def _create(x,
            y,
            name,
            char,
            weight,
            item_type,
            equip_to=None,
            fore_color=(255, 255, 255),
            kind=None):
    _entity = entities.create_entity(group='items')

    _entity['stats'] = {
        'name': name,
        'display_name': name,
        'type': item_type,
        'weight': weight,
        'owner': None,
        'kind': kind,
        'equip_to': equip_to,
        'in_container': None
    }

    movement.register(_entity)
    flags.register(_entity)
    tile.register(_entity, surface='items', char=char, fore_color=fore_color)

    entities.create_event(_entity, 'collision_with_solid')
    entities.create_event(_entity, 'collision_with_entity')
    entities.create_event(_entity, 'get_interactions')
    entities.create_event(_entity, 'get_actions')
    entities.create_event(_entity, 'get_display_name')
    entities.create_event(_entity, 'seen')
    entities.register_event(_entity, 'get_display_name', get_display_name)

    entities.trigger_event(_entity, 'set_position', x=x, y=y)

    return _entity
Esempio n. 34
0
def register(entity, x=0, y=0, direction=0, turn_speed=15, collisions=False):
	_movement = {'x': x,
				 'y': y,
	             'next_x': x,
	             'next_y': y,
	             'collisions': collisions,
				 'direction': direction,
				 'turn_speed': turn_speed,
	             'override_speed': 6,
	             'path': {'positions': [],
	                      'destination': None,
	                      'refresh': False}}

	entity['movement'] = _movement

	entities.create_event(entity, 'set_position')
	entities.create_event(entity, 'set_direction')
	entities.create_event(entity, 'set_turn_speed')
	entities.create_event(entity, 'push_tank')
	entities.create_event(entity, 'push')
	entities.create_event(entity, 'warp')
	entities.create_event(entity, 'throw')
	entities.create_event(entity, 'thrown')
	entities.create_event(entity, 'position_changed')
	entities.create_event(entity, 'recovering')
	entities.create_event(entity, 'check_next_position')
	entities.create_event(entity, 'move_to_position')
	entities.create_event(entity, 'disable_collisions')
	entities.create_event(entity, 'enable_collisions')
	entities.create_event(entity, 'stop')
	entities.register_event(entity, 'save', save)
	entities.register_event(entity, 'tick', _walk_path)
	entities.register_event(entity, 'push', _push)
	entities.register_event(entity, 'stop', stop)
	entities.register_event(entity, 'set_turn_speed', set_turn_speed)
	entities.register_event(entity, 'set_position', set_position)
	entities.register_event(entity, 'set_direction', _set_tank_direction)
	entities.register_event(entity, 'push_tank', _push_tank)
	entities.register_event(entity, 'move_to_position', walk_to_position)
	entities.register_event(entity, 'enable_collisions', _enable_collisions)
	entities.register_event(entity, 'disable_collisions', _disable_collisions)
Esempio n. 35
0
def _create_robot(x, y, health, speed, name, vision=30, faction='Rogues', is_player=False, has_ai=True, fore_color=(200, 200, 200)):
	_entity = entities.create_entity(group='life')
	
	entities.create_event(_entity, 'get_and_store_item')
	entities.create_event(_entity, 'get_and_hold_item')
	entities.create_event(_entity, 'reload')
	entities.create_event(_entity, 'shoot')
	entities.create_event(_entity, 'damage')
	entities.create_event(_entity, 'did_damage')
	entities.create_event(_entity, 'receive_memory')
	entities.create_event(_entity, 'handle_corpse')
	entities.create_event(_entity, 'finish_turn')

	tile.register(_entity, surface='life', char='@', fore_color=fore_color)
	movement.register(_entity, collisions=True)
	timers.register(_entity)
	stats.register(_entity, health, speed, vision, name=name, kind='human')
	nodes.register(_entity)
	items.register(_entity)
	flags.register(_entity)
	noise.register(_entity)
	missions.register(_entity)
	skeleton.register(_entity)

	if has_ai:
		ai.register_robot(_entity)
	
	ai_factions.register(_entity, faction)
	
	_entity['ai']['is_player'] = is_player
	_entity['ai']['is_npc'] = not is_player
	
	if is_player:
		entities.register_event(_entity,
		                        'did_damage',
		                        lambda e, target_id, damage: effects.printer(entities.get_entity(target_id)['tile']['x'],
		                                            entities.get_entity(target_id)['tile']['y']-1,
		                                            '%s' % damage,
		                                            fore_color=(200, 0, 0),
		                                            speed_mod=0.3,
		                                            show_mod=1.0,
		                                            moving=True,
		                                            center=True))
		entities.register_event(_entity,
		                        'log_kill',
		                        lambda e, target_id: effects.printer(entities.get_entity(target_id)['tile']['x'],
		                                            entities.get_entity(target_id)['tile']['y']-1,
		                                            'KILL',
		                                            fore_color=(255, 0, 0),
		                                            speed_mod=0.3,
		                                            show_mod=1.0,
		                                            moving=True,
		                                            center=True))

	entities.register_event(_entity, 'delete', _handle_robot_death)
	entities.register_event(_entity, 'finish_turn', finish_turn)
	entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
	entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
	entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
	entities.register_event(_entity, 'reload', reload_weapon)
	entities.register_event(_entity, 'shoot', shoot_weapon)
	entities.register_event(_entity, 'heard_noise', handle_heard_noise)
	entities.register_event(_entity, 'position_changed',
	                        lambda e, **kwargs: entities.trigger_event(e,
	                                                                   'create_noise',
	                                                                   volume=25,
	                                                                   text='?',
	                                                                   callback=lambda t, x, y: entities.trigger_event(t,
	                                                                                                            'update_target_memory',
	                                                                                                            target_id=_entity['_id'],
	                                                                                                            key='last_seen_at',
	                                                                                                            value=[x, y])))
	entities.register_event(_entity, 'push', lambda e, **kwargs: movement.sub_move_cost(e))
	                        
	entities.trigger_event(_entity, 'set_position', x=x, y=y)
	entities.trigger_event(_entity, 'create_holder', name='weapon', max_weight=10)
	entities.trigger_event(_entity, 'create_holder', name='backpack', max_weight=10)
	
	_get_and_hold_item(_entity, items.leather_backpack(20, 20)['_id'])

	return _entity
Esempio n. 36
0
def _create_human(x,
                  y,
                  health,
                  speed,
                  name,
                  vision=50,
                  faction='Rogues',
                  is_player=False,
                  has_ai=False,
                  fore_color=(255, 255, 255)):
    _entity = entities.create_entity(group='life')

    entities.create_event(_entity, 'get_and_store_item')
    entities.create_event(_entity, 'get_and_hold_item')
    entities.create_event(_entity, 'reload')
    entities.create_event(_entity, 'shoot')
    entities.create_event(_entity, 'damage')
    entities.create_event(_entity, 'did_damage')
    entities.create_event(_entity, 'receive_memory')
    entities.create_event(_entity, 'handle_corpse')
    entities.create_event(_entity, 'finish_turn')

    tile.register(_entity, surface='life', char='@', fore_color=fore_color)
    movement.register(_entity, collisions=True)
    timers.register(_entity)
    stats.register(_entity, health, speed, vision, name=name, kind='human')
    nodes.register(_entity)
    items.register(_entity)
    flags.register(_entity)
    noise.register(_entity)
    missions.register(_entity)
    skeleton.register(_entity)
    skeleton.create_motion(_entity, 'stand')
    skeleton.create_motion(_entity, 'crouch', stat_mod={'mobility': 1.55})
    skeleton.create_motion(_entity, 'crawl', stat_mod={'mobility': 2.3})
    skeleton.create_limb(_entity,
                         'head', [],
                         True,
                         0.1,
                         stat_mod={'vision': .75})
    skeleton.create_limb(_entity,
                         'chest', ['head'],
                         True,
                         0.88,
                         stat_mod={'mobility': .1})
    skeleton.create_limb(_entity,
                         'torso', ['chest'],
                         True,
                         0.75,
                         stat_mod={'mobility': .6})
    skeleton.create_limb(_entity,
                         'left arm', ['chest'],
                         False,
                         0.3,
                         can_sever=True,
                         stat_mod={'accuracy': .22})
    skeleton.create_limb(_entity,
                         'right arm', ['chest'],
                         False,
                         0.3,
                         can_sever=True,
                         stat_mod={'accuracy': .22})
    skeleton.create_limb(_entity,
                         'left leg', ['torso'],
                         False,
                         0.45,
                         can_sever=True,
                         stat_mod={'mobility': .4})
    skeleton.create_limb(_entity,
                         'right leg', ['torso'],
                         False,
                         0.45,
                         can_sever=True,
                         stat_mod={'mobility': .4})

    if has_ai:
        ai.register_human(_entity)

    ai_factions.register(_entity, faction)

    _entity['ai']['is_player'] = is_player
    _entity['ai']['is_npc'] = not is_player

    if faction == 'Rogues':
        entities.register_event(
            _entity, 'did_damage', lambda e, target_id, damage: effects.
            printer(entities.get_entity(target_id)['tile']['x'],
                    entities.get_entity(target_id)['tile']['y'] - 1,
                    '%s' % damage,
                    fore_color=(200, 0, 0),
                    speed_mod=0.3,
                    show_mod=1.0,
                    moving=True,
                    center=True))
        entities.register_event(
            _entity, 'log_kill', lambda e, target_id: effects.printer(
                entities.get_entity(target_id)['tile']['x'],
                entities.get_entity(target_id)['tile']['y'] - 1,
                'KILL',
                fore_color=(255, 0, 0),
                speed_mod=0.3,
                show_mod=1.0,
                moving=True,
                center=True))

    entities.register_event(_entity, 'finish_turn', finish_turn)
    entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
    entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
    entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
    entities.register_event(_entity, 'reload', reload_weapon)
    entities.register_event(_entity, 'shoot', shoot_weapon)
    entities.register_event(_entity, 'heard_noise', handle_heard_noise)
    entities.register_event(
        _entity, 'position_changed', lambda e, **kwargs: entities.
        trigger_event(e,
                      'create_noise',
                      volume=25,
                      text='?',
                      callback=lambda t, x, y: entities.trigger_event(
                          t,
                          'update_target_memory',
                          target_id=_entity['_id'],
                          key='last_seen_at',
                          value=[x, y])))
    #entities.register_event(_entity, 'damage',
    #                        lambda e, **kwargs: entities.trigger_event(e,
    #                                                                   'create_noise',
    #                                                                   volume=12,
    #                                                                   text='Ow!',
    #                                                                   owner_can_hear=True,
    #                                                                   show_on_sight=True,
    #                                                                   callback=lambda t, x, y: entities.trigger_event(t,
    #                                                                                                            'update_target_memory',
    #                                                                                                            target_id=_entity['_id'],
    #                                                                                                            key='last_seen_at',
    #                                                                                                            value=[x, y])))
    #entities.register_event(_entity, 'position_changed', lambda e, **kwargs: ai_visuals.add_to_moved_life(e))
    entities.register_event(_entity, 'push',
                            lambda e, **kwargs: movement.sub_move_cost(e))

    entities.trigger_event(_entity, 'set_position', x=x, y=y)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='weapon',
                           max_weight=10)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='backpack',
                           max_weight=10)

    _get_and_hold_item(_entity, items.leather_backpack(20, 20)['_id'])

    return _entity
Esempio n. 37
0
def register(entity, x=0, y=0, direction=0, turn_speed=15, collisions=False):
    _movement = {
        'x': x,
        'y': y,
        'next_x': x,
        'next_y': y,
        'collisions': collisions,
        'direction': direction,
        'turn_speed': turn_speed,
        'override_speed': 6,
        'path': {
            'positions': [],
            'destination': None,
            'refresh': False
        }
    }

    entity['movement'] = _movement

    entities.create_event(entity, 'set_position')
    entities.create_event(entity, 'set_direction')
    entities.create_event(entity, 'set_turn_speed')
    entities.create_event(entity, 'push_tank')
    entities.create_event(entity, 'push')
    entities.create_event(entity, 'warp')
    entities.create_event(entity, 'throw')
    entities.create_event(entity, 'thrown')
    entities.create_event(entity, 'position_changed')
    entities.create_event(entity, 'recovering')
    entities.create_event(entity, 'check_next_position')
    entities.create_event(entity, 'move_to_position')
    entities.create_event(entity, 'disable_collisions')
    entities.create_event(entity, 'enable_collisions')
    entities.create_event(entity, 'stop')
    entities.register_event(entity, 'save', save)
    entities.register_event(entity, 'tick', _walk_path)
    entities.register_event(entity, 'push', _push)
    entities.register_event(entity, 'stop', stop)
    entities.register_event(entity, 'set_turn_speed', set_turn_speed)
    entities.register_event(entity, 'set_position', set_position)
    entities.register_event(entity, 'set_direction', _set_tank_direction)
    entities.register_event(entity, 'push_tank', _push_tank)
    entities.register_event(entity, 'move_to_position', walk_to_position)
    entities.register_event(entity, 'enable_collisions', _enable_collisions)
    entities.register_event(entity, 'disable_collisions', _disable_collisions)
Esempio n. 38
0
def _create_human(x, y, health, speed, name, vision=50, faction='Rogues', is_player=False, has_ai=False, fore_color=(255, 255, 255)):
	_entity = entities.create_entity(group='life')
	
	entities.create_event(_entity, 'get_and_store_item')
	entities.create_event(_entity, 'get_and_hold_item')
	entities.create_event(_entity, 'reload')
	entities.create_event(_entity, 'shoot')
	entities.create_event(_entity, 'damage')
	entities.create_event(_entity, 'did_damage')
	entities.create_event(_entity, 'receive_memory')
	entities.create_event(_entity, 'handle_corpse')
	entities.create_event(_entity, 'finish_turn')

	tile.register(_entity, surface='life', char='@', fore_color=fore_color)
	movement.register(_entity, collisions=True)
	timers.register(_entity)
	stats.register(_entity, health, speed, vision, name=name, kind='human')
	nodes.register(_entity)
	items.register(_entity)
	flags.register(_entity)
	noise.register(_entity)
	missions.register(_entity)
	skeleton.register(_entity)
	skeleton.create_motion(_entity, 'stand')
	skeleton.create_motion(_entity, 'crouch', stat_mod={'mobility': 1.55})
	skeleton.create_motion(_entity, 'crawl', stat_mod={'mobility': 2.3})
	skeleton.create_limb(_entity, 'head', [], True, 0.1, stat_mod={'vision': .75})
	skeleton.create_limb(_entity, 'chest', ['head'], True, 0.88, stat_mod={'mobility': .1})
	skeleton.create_limb(_entity, 'torso', ['chest'], True, 0.75, stat_mod={'mobility': .6})
	skeleton.create_limb(_entity, 'left arm', ['chest'], False, 0.3, can_sever=True, stat_mod={'accuracy': .22})
	skeleton.create_limb(_entity, 'right arm', ['chest'], False, 0.3, can_sever=True, stat_mod={'accuracy': .22})
	skeleton.create_limb(_entity, 'left leg', ['torso'], False, 0.45, can_sever=True, stat_mod={'mobility': .4})
	skeleton.create_limb(_entity, 'right leg', ['torso'], False, 0.45, can_sever=True, stat_mod={'mobility': .4})

	if has_ai:
		ai.register_human(_entity)
	
	ai_factions.register(_entity, faction)
	
	_entity['ai']['is_player'] = is_player
	_entity['ai']['is_npc'] = not is_player
	
	if faction == 'Rogues':
		entities.register_event(_entity,
		                        'did_damage',
		                        lambda e, target_id, damage: effects.printer(entities.get_entity(target_id)['tile']['x'],
		                                            entities.get_entity(target_id)['tile']['y']-1,
		                                            '%s' % damage,
		                                            fore_color=(200, 0, 0),
		                                            speed_mod=0.3,
		                                            show_mod=1.0,
		                                            moving=True,
		                                            center=True))
		entities.register_event(_entity,
		                        'log_kill',
		                        lambda e, target_id: effects.printer(entities.get_entity(target_id)['tile']['x'],
		                                            entities.get_entity(target_id)['tile']['y']-1,
		                                            'KILL',
		                                            fore_color=(255, 0, 0),
		                                            speed_mod=0.3,
		                                            show_mod=1.0,
		                                            moving=True,
		                                            center=True))

	entities.register_event(_entity, 'finish_turn', finish_turn)
	entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
	entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
	entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
	entities.register_event(_entity, 'reload', reload_weapon)
	entities.register_event(_entity, 'shoot', shoot_weapon)
	entities.register_event(_entity, 'heard_noise', handle_heard_noise)
	entities.register_event(_entity, 'position_changed',
	                        lambda e, **kwargs: entities.trigger_event(e,
	                                                                   'create_noise',
	                                                                   volume=25,
	                                                                   text='?',
	                                                                   callback=lambda t, x, y: entities.trigger_event(t,
	                                                                                                            'update_target_memory',
	                                                                                                            target_id=_entity['_id'],
	                                                                                                            key='last_seen_at',
	                                                                                                            value=[x, y])))
	#entities.register_event(_entity, 'damage',
	#                        lambda e, **kwargs: entities.trigger_event(e,
	#                                                                   'create_noise',
	#                                                                   volume=12,
	#                                                                   text='Ow!',
	#                                                                   owner_can_hear=True,
	#                                                                   show_on_sight=True,
	#                                                                   callback=lambda t, x, y: entities.trigger_event(t,
	#                                                                                                            'update_target_memory',
	#                                                                                                            target_id=_entity['_id'],
	#                                                                                                            key='last_seen_at',
	#                                                                                                            value=[x, y])))
	#entities.register_event(_entity, 'position_changed', lambda e, **kwargs: ai_visuals.add_to_moved_life(e))
	entities.register_event(_entity, 'push', lambda e, **kwargs: movement.sub_move_cost(e))
	                        
	entities.trigger_event(_entity, 'set_position', x=x, y=y)
	entities.trigger_event(_entity, 'create_holder', name='weapon', max_weight=10)
	entities.trigger_event(_entity, 'create_holder', name='backpack', max_weight=10)
	
	_get_and_hold_item(_entity, items.leather_backpack(20, 20)['_id'])

	return _entity
Esempio n. 39
0
def _create_robot(x,
                  y,
                  health,
                  speed,
                  name,
                  vision=30,
                  faction='Rogues',
                  is_player=False,
                  has_ai=True,
                  fore_color=(200, 200, 200)):
    _entity = entities.create_entity(group='life')

    entities.create_event(_entity, 'get_and_store_item')
    entities.create_event(_entity, 'get_and_hold_item')
    entities.create_event(_entity, 'reload')
    entities.create_event(_entity, 'shoot')
    entities.create_event(_entity, 'damage')
    entities.create_event(_entity, 'did_damage')
    entities.create_event(_entity, 'receive_memory')
    entities.create_event(_entity, 'handle_corpse')
    entities.create_event(_entity, 'finish_turn')

    tile.register(_entity, surface='life', char='@', fore_color=fore_color)
    movement.register(_entity, collisions=True)
    timers.register(_entity)
    stats.register(_entity, health, speed, vision, name=name, kind='human')
    nodes.register(_entity)
    items.register(_entity)
    flags.register(_entity)
    noise.register(_entity)
    missions.register(_entity)
    skeleton.register(_entity)

    if has_ai:
        ai.register_robot(_entity)

    ai_factions.register(_entity, faction)

    _entity['ai']['is_player'] = is_player
    _entity['ai']['is_npc'] = not is_player

    if is_player:
        entities.register_event(
            _entity, 'did_damage', lambda e, target_id, damage: effects.
            printer(entities.get_entity(target_id)['tile']['x'],
                    entities.get_entity(target_id)['tile']['y'] - 1,
                    '%s' % damage,
                    fore_color=(200, 0, 0),
                    speed_mod=0.3,
                    show_mod=1.0,
                    moving=True,
                    center=True))
        entities.register_event(
            _entity, 'log_kill', lambda e, target_id: effects.printer(
                entities.get_entity(target_id)['tile']['x'],
                entities.get_entity(target_id)['tile']['y'] - 1,
                'KILL',
                fore_color=(255, 0, 0),
                speed_mod=0.3,
                show_mod=1.0,
                moving=True,
                center=True))

    entities.register_event(_entity, 'delete', _handle_robot_death)
    entities.register_event(_entity, 'finish_turn', finish_turn)
    entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
    entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
    entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
    entities.register_event(_entity, 'reload', reload_weapon)
    entities.register_event(_entity, 'shoot', shoot_weapon)
    entities.register_event(_entity, 'heard_noise', handle_heard_noise)
    entities.register_event(
        _entity, 'position_changed', lambda e, **kwargs: entities.
        trigger_event(e,
                      'create_noise',
                      volume=25,
                      text='?',
                      callback=lambda t, x, y: entities.trigger_event(
                          t,
                          'update_target_memory',
                          target_id=_entity['_id'],
                          key='last_seen_at',
                          value=[x, y])))
    entities.register_event(_entity, 'push',
                            lambda e, **kwargs: movement.sub_move_cost(e))

    entities.trigger_event(_entity, 'set_position', x=x, y=y)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='weapon',
                           max_weight=10)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='backpack',
                           max_weight=10)

    _get_and_hold_item(_entity, items.leather_backpack(20, 20)['_id'])

    return _entity
Esempio n. 40
0
def _create_animal(x,
                   y,
                   health,
                   speed,
                   name,
                   vision=65,
                   faction='Mutants',
                   has_ai=False,
                   char='m',
                   fore_color=(255, 255, 255)):
    _entity = entities.create_entity(group='life')

    entities.create_event(_entity, 'damage')
    entities.create_event(_entity, 'did_damage')
    entities.create_event(_entity, 'receive_memory')
    entities.create_event(_entity, 'handle_corpse')
    entities.create_event(_entity, 'finish_turn')

    tile.register(_entity, surface='life', char=char, fore_color=fore_color)
    movement.register(_entity, collisions=True)
    timers.register(_entity)
    stats.register(_entity, health, speed, vision, name=name, kind='animal')
    nodes.register(_entity)
    items.register(_entity)
    flags.register(_entity)
    noise.register(_entity)
    skeleton.register(_entity)
    ai_factions.register(_entity, faction)

    if has_ai:
        ai.register_animal(_entity)

    _entity['ai']['is_npc'] = True

    entities.register_event(_entity, 'finish_turn', finish_turn)
    entities.create_event(_entity, 'get_and_store_item')
    entities.create_event(_entity, 'get_and_hold_item')
    entities.create_event(_entity, 'reload')
    entities.create_event(_entity, 'shoot')
    entities.create_event(_entity, 'damage')
    entities.register_event(_entity, 'post_tick', ai_visuals.cleanup)
    entities.register_event(_entity, 'get_and_store_item', get_and_store_item)
    entities.register_event(_entity, 'get_and_hold_item', get_and_hold_item)
    entities.register_event(_entity, 'reload', reload_weapon)
    entities.register_event(_entity, 'shoot', shoot_weapon)
    entities.register_event(_entity, 'heard_noise', handle_heard_noise)
    entities.register_event(
        _entity, 'position_changed', lambda e, **kwargs: entities.
        trigger_event(e,
                      'create_noise',
                      volume=25,
                      text='?',
                      owner_can_hear=False,
                      callback=lambda t, x, y: entities.trigger_event(
                          t,
                          'update_target_memory',
                          target_id=_entity['_id'],
                          key='last_seen_at',
                          value=[x, y])))
    #entities.register_event(_entity, 'position_changed', lambda e, **kwargs: ai_visuals.add_to_moved_life(e))
    entities.register_event(_entity, 'push',
                            lambda e, **kwargs: movement.sub_move_cost(e))

    entities.trigger_event(_entity, 'set_position', x=x, y=y)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='weapon',
                           max_weight=10)
    entities.trigger_event(_entity,
                           'create_holder',
                           name='backpack',
                           max_weight=10)

    return _entity
Esempio n. 41
0
def _create(x, y, name, char, weight, item_type, equip_to=None, fore_color=(255, 255, 255), kind=None):
	_entity = entities.create_entity(group='items')
	
	_entity['stats'] = {'name': name,
	                    'display_name': name,
	                    'type': item_type,
	                    'weight': weight,
	                    'owner': None,
	                    'kind': kind,
	                    'equip_to': equip_to,
	                    'in_container': None}
	
	movement.register(_entity)
	flags.register(_entity)
	tile.register(_entity, surface='items', char=char, fore_color=fore_color)
	
	entities.create_event(_entity, 'collision_with_solid')
	entities.create_event(_entity, 'collision_with_entity')
	entities.create_event(_entity, 'get_interactions')
	entities.create_event(_entity, 'get_actions')
	entities.create_event(_entity, 'get_display_name')
	entities.create_event(_entity, 'seen')
	entities.register_event(_entity, 'get_display_name', get_display_name)
	
	entities.trigger_event(_entity, 'set_position', x=x, y=y)
	
	return _entity
Esempio n. 42
0
File: ai.py Progetto: penny64/r3-tdw
def _register(entity, player=False):
    ONLINE_ENTITIES.append(entity['_id'])

    entity['ai'] = {
        'brain': goapy.World(),
        'brain_offline': goapy.World(),
        'current_action': 'idle',
        'last_action': 'idle',
        'visible_items': {},
        'visible_life': set(),
        'visible_targets': [],
        'targets_to_search': [],
        'targets': set(),
        'nearest_target': None,
        'life_memory': {},
        'is_player': player,
        'is_npc': False,
        'meta': {
            'is_injured': False,
            'is_panicked': False,
            'is_squad_combat_ready': False,
            'is_squad_overwhelmed': False,
            'is_squad_forcing_surrender': False,
            'is_squad_mobile_ready': False,
            'is_squad_leader': False,
            'has_bandage': False,
            'has_ammo': False,
            'has_weapon': False,
            'has_container': False,
            'has_firing_position': False,
            'has_lost_target': False,
            'weapon_loaded': False,
            'in_engagement': False,
            'is_target_near': False,
            'is_target_armed': False,
            'in_cover': False,
            'in_enemy_los': False,
            'in_firing_range': False,
            'is_hungry': False,
            'has_food': False,
            'sees_item_type_weapon': False,
            'sees_item_type_container': False,
            'sees_item_type_ammo': False,
            'has_needs': False
        },
        'weights': {
            'find_bandage': 10,
            'find_weapon': 16,
            'find_container': 14,
            'track': 20
        }
    }

    entities.create_event(entity, 'logic_offline')
    entities.create_event(entity, 'update_target_memory')
    entities.create_event(entity, 'meta_change')
    entities.create_event(entity, 'set_meta')
    entities.create_event(entity, 'has_needs')
    entities.create_event(entity, 'new_target_spotted')
    entities.create_event(entity, 'broadcast')
    entities.create_event(entity, 'target_lost')
    entities.create_event(entity, 'target_found')
    entities.create_event(entity, 'target_search_failed')
    entities.create_event(entity, 'squad_inform_lost_target')
    entities.create_event(entity, 'squad_inform_found_target')
    entities.create_event(entity, 'squad_inform_failed_search')
    entities.register_event(entity, 'save', save)
    entities.register_event(entity, 'delete', _cleanup)
    entities.register_event(entity, 'set_meta', set_meta)
    entities.register_event(entity, 'update_target_memory',
                            update_target_memory)
    entities.register_event(entity, 'target_lost',
                            ai_squad_logic.member_handle_lost_target)
    entities.register_event(entity, 'target_found',
                            ai_squad_logic.member_handle_found_target)
    entities.register_event(entity, 'target_search_failed',
                            ai_squad_logic.member_handle_failed_target_search)
    entities.register_event(entity, 'squad_inform_lost_target',
                            ai_squad_logic.member_learn_lost_target)
    entities.register_event(entity, 'squad_inform_found_target',
                            ai_squad_logic.member_learn_found_target)
    entities.register_event(entity, 'squad_inform_failed_search',
                            ai_squad_logic.member_learn_failed_target_search)
Esempio n. 43
0
def register(entity, health, speed, vision, class_name='Gunner', respect=1, accuracy=1.0, mobility=80, explosives=70, intelligence=90, action_points=100, smgs=50, rifles=50, pistols=50, name='Unknown', kind='unknown'):
	_stats = {'health': health,
	          'max_health': health,
	          'speed': speed,
	          'max_speed': speed,
	          'pain': 0,
	          'accuracy': accuracy,
	          'max_accuracy': accuracy,
	          'vision': vision,
	          'max_vision': vision,
	          'action_points': action_points,
	          'action_points_max': action_points,
	          'intelligence': intelligence,
	          'skill_points': int(round(100 * (intelligence/100.0))),
	          'mobility': mobility,
	          'max_mobility': mobility,
	          'class': class_name,
	          'smgs': smgs,
	          'rifles': rifles,
	          'pistols': pistols,
	          'explosives': explosives,
	          'name': name,
	          'kind': kind,
	          'last_engaged': None,
	          'respect': 0,
	          'rank': 'Unknown',
	          'last_rank': 'Unknown',
	          'kills': 0}
	
	entity['stats'] = _stats

	entities.create_event(entity, 'kill')
	entities.create_event(entity, 'killed_by')
	entities.create_event(entity, 'log_kill')
	entities.create_event(entity, 'heal')
	entities.create_event(entity, 'haste')
	entities.create_event(entity, 'slow')
	entities.create_event(entity, 'set_respect')
	entities.create_event(entity, 'set_rank')
	entities.create_event(entity, 'get_mobility')
	entities.create_event(entity, 'get_vision')
	entities.create_event(entity, 'get_accuracy')
	entities.register_event(entity, 'kill', kill)
	entities.register_event(entity, 'set_respect', set_respect)
	entities.register_event(entity, 'set_rank', set_rank)
	entities.register_event(entity, 'log_kill', add_respect)
	entities.register_event(entity, 'log_kill', log_kill)
	entities.register_event(entity, 'save', save)
	entities.trigger_event(entity, 'set_respect', respect=respect)