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 _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. 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 fire(x, y, amount):
	_blood = _create(x, y)
	_x, _y = (int(round(x)), int(round(y)))
	
	flags.register(_blood)
	timers.register(_blood)
	
	entities.trigger_event(_blood, 'set_flag', flag='alpha', value=amount)
	entities.trigger_event(_blood, 'set_flag', flag='alpha_max', value=amount)
	entities.trigger_event(_blood, 'set_char', char=' ')

	_color = list(display.get_color_at('tiles', _x, _y))
	_color[0] = numbers.interp_velocity(_color[0], random.choice([constants.FIRE_1, constants.FIRE_2, constants.FIRE_3]), amount)
	_color[1] = numbers.interp_velocity(_color[1], random.choice([constants.FIRE_1, constants.FIRE_2, constants.FIRE_3]), amount)
	
	for c in range(len(_color)):
		for i in range(len(_color)):
			_color[c][i] = int((round(_color[c][i])))
	
	#display._set_char('tiles', _x, _y, random.choice([',', '.', '^']), _color[0], _color[1])
	entities.register_event(_blood, 'tick', _tick_fire)
	entities.register_event(_blood, 'position_changed', lambda e, x, y, **kwargs: char(x, y, flags.get_flag(e, 'alpha')))
	entities.trigger_event(_blood, 'create_timer', time=120, repeat=-1, repeat_callback=lambda e: movement.push(e,
	                                                                                                            random.randint(-1, 1),
	                                                                                                            random.randint(-1, 1),
	                                                                                                            time=1))
	entities.trigger_event(_blood, 'set_fore_color', color=_color[0])
	entities.trigger_event(_blood, 'set_back_color', color=_color[1])
	entities.trigger_event(_blood, 'set_position', x=_x, y=_y)
	
	#light(_x, _y, random.randint(5, 7), r=1.5, g=.1, b=.1)

	return _blood
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 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. 7
0
def start():
	global PROCESSOR
	
	_entity = entities.create_entity(group='systems')
	
	PROCESSOR = _entity
	
	timers.register(_entity, use_system_event='post_process')
Esempio n. 8
0
def start():
    global PROCESSOR

    _entity = entities.create_entity(group='systems')

    PROCESSOR = _entity

    timers.register(_entity, use_system_event='post_process')
Esempio n. 9
0
def boot():
	global DIRECTOR
	
	_entity = entities.create_entity(group='systems')
	DIRECTOR = _entity
	
	events.register_event('input', handle_keyboard_input)
	
	timers.register(_entity)
Esempio n. 10
0
def boot():
    global DIRECTOR

    _entity = entities.create_entity(group='systems')
    DIRECTOR = _entity

    events.register_event('input', handle_keyboard_input)

    timers.register(_entity)
Esempio n. 11
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. 12
0
def _create(x, y, surface='effects', group='effects'):
	_entity = entities.create_entity()

	movement.register(_entity)
	tile.register(_entity, surface=surface)
	
	timers.register(_entity)
	entities.add_entity_to_group(_entity, group)

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

	return _entity
Esempio n. 13
0
def create_context(x, y, text, callback):
	_entity = entities.create_entity(group='contexts')
	_entity['text'] = text
	_entity['callback'] = callback
	
	tile.register(_entity, surface='effects', char='!', fore_color=(0, 200, 0))
	timers.register(_entity, use_system_event='logic')
	
	entities.trigger_event(_entity, 'set_position', x=x, y=y)
	entities.trigger_event(_entity, 'animate', animation=['!', ' '], repeat=-1)
	entities.trigger_event(_entity, 'create_timer', time=120, exit_callback=entities.delete_entity)
	
	return _entity
Esempio n. 14
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. 15
0
def blood_splatter(x, y, direction):
	_blood = _create(x, y)
	_x, _y = (int(round(x)), int(round(y)))
	
	blood(_x, _y)
	
	flags.register(_blood)
	timers.register(_blood)
	
	entities.trigger_event(_blood, 'set_direction', direction=direction)
	#entities.trigger_event(_blood, 'set_flag', flag='speed', value=random.)
	
	entities.trigger_event(_blood, 'create_timer', time=random.randint(24, 32), repeat=random.randint(2, 3), repeat_callback=_blood_splatter_push,
	                       exit_callback=entities.delete_entity)
Esempio n. 16
0
def bullet(entity, x, y, tx, ty, speed, accuracy, damage):
    _entity = _create(x, y, 'Bullet', '.', 0, 'bullet')
    _entity['owner'] = entity['_id']
    _entity['start_position'] = (x, y)
    _entity['end_position'] = (tx, ty)
    _entity['speed'] = speed
    _entity['damage'] = damage

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

    entities.trigger_event(_entity,
                           'set_direction',
                           direction=numbers.direction_to(
                               (x, y),
                               (tx, ty)) + random.uniform(-accuracy, accuracy))
    entities.trigger_event(_entity,
                           'create_timer',
                           time=speed,
                           repeat=-1,
                           enter_callback=_bullet_tick,
                           repeat_callback=_bullet_tick)
    entities.register_event(_entity, 'position_changed',
                            lambda e, **kwargs: check_for_collisions(e))
    entities.register_event(
        _entity, 'collision_with_entity', lambda e, target_id: entities.
        trigger_event(entities.get_entity(target_id), 'hit', projectile=e))
    entities.register_event(_entity, 'collision_with_entity',
                            lambda e, target_id: entities.delete_entity(e))
    entities.register_event(
        _entity, 'collision_with_solid', lambda e: effects.light(
            movement.get_position(e)[0],
            movement.get_position(e)[1], random.randint(3, 4)))
    entities.register_event(_entity, 'collision_with_solid',
                            lambda e: entities.delete_entity(e))
    entities.register_event(
        _entity, 'collision_with_solid',
        lambda e: effects.smoke_cloud(movement.get_position(e)[0],
                                      movement.get_position(e)[1],
                                      random.uniform(2, 2.75),
                                      start_alpha=random.uniform(0.45, .65),
                                      decay_amount=1.5))
    entities.register_event(_entity, 'check_next_position',
                            check_next_position)

    if not '--no-fx' in sys.argv:
        entities.register_event(
            _entity, 'position_changed',
            lambda e, x, y, **kwargs: _bullet_effects(e, x, y))
Esempio n. 17
0
def create_context(x, y, text, callback):
    _entity = entities.create_entity(group='contexts')
    _entity['text'] = text
    _entity['callback'] = callback

    tile.register(_entity, surface='effects', char='!', fore_color=(0, 200, 0))
    timers.register(_entity, use_system_event='logic')

    entities.trigger_event(_entity, 'set_position', x=x, y=y)
    entities.trigger_event(_entity, 'animate', animation=['!', ' '], repeat=-1)
    entities.trigger_event(_entity,
                           'create_timer',
                           time=120,
                           exit_callback=entities.delete_entity)

    return _entity
Esempio n. 18
0
def create():
	global MAP, FADER
	
	worlds.create('strategy')
	words.reset()
	
	display.create_surface('background')
	display.create_surface('map', width=constants.STRAT_MAP_WIDTH, height=constants.STRAT_MAP_HEIGHT)
	display.create_surface('map_markers', width=constants.STRAT_MAP_WIDTH, height=constants.STRAT_MAP_HEIGHT)
	display.create_surface('map_squads', width=constants.STRAT_MAP_WIDTH, height=constants.STRAT_MAP_HEIGHT)
	display.create_surface('map_path', width=constants.STRAT_MAP_WIDTH, height=constants.STRAT_MAP_HEIGHT)
	display.create_surface('ui_bar', width=constants.WINDOW_WIDTH, height=constants.WINDOW_HEIGHT-constants.STRAT_MAP_HEIGHT)
	display.fill_surface('ui_bar', (30, 30, 30))
	display.blit_background('background')
	
	register_input()
	
	entities.create_entity_group('life', static=True)
	entities.create_entity_group('items', static=True)
	entities.create_entity_group('factions', static=True)
	entities.create_entity_group('squads', static=True)
	entities.create_entity_group('systems')
	
	FADER = entities.create_entity()
	timers.register(FADER)
	fade_in()
	
	_grid = {}
	_color_map = {}
	
	MAP = {'grid': _grid,
	       'color_map': _color_map,
	       'astar_map': None,
	       'astar_weight_map': numpy.ones((constants.STRAT_MAP_HEIGHT/constants.MAP_CELL_SPACE,
	                                       constants.STRAT_MAP_WIDTH/constants.MAP_CELL_SPACE))}
	
	for x in range(constants.STRAT_MAP_WIDTH/constants.MAP_CELL_SPACE):
		for y in range(constants.STRAT_MAP_HEIGHT/constants.MAP_CELL_SPACE):
			_grid[x, y] = {'owned_by': None,
			               'is_ownable': False,
			               'squads': [],
			               'income': .025}
	
	worldgen.generate()
	
	unregister_input()
	world_action._start_battle(attacking_squads=[entities.get_entity_group('squads')[0]], defending_squads=[entities.get_entity_group('squads')[1]])
Esempio n. 19
0
def smoke_shooter(x, y, direction):
	_blood = _create(x, y)
	_x, _y = (int(round(x)), int(round(y)))
	
	_v_x, _v_y = numbers.velocity(direction, random.randint(4, 6))
	
	_x = int(round(_x + _v_x))
	_y = int(round(_y + _v_y))
	
	flags.register(_blood)
	timers.register(_blood)
	
	entities.trigger_event(_blood, 'set_flag', flag='alpha', value=1.0)
	
	entities.trigger_event(_blood, 'set_direction', direction=direction)
	
	entities.trigger_event(_blood, 'create_timer', time=random.randint(3, 6), repeat=random.randint(2, 4), repeat_callback=_smoke_shooter_push,
	                       exit_callback=entities.delete_entity)
Esempio n. 20
0
def _start_battle(attacking_squads=[], defending_squads=[]):
	global FADER
	
	create()
	
	_width, _height, _node_grid, _node_sets, _weight_map, _tile_map, _solids, _fsl, _trees, _inside, _lights, _spawns = mapgen_arena.generate(200, 200)
	_zone = zones.create('swamps', _width, _height, _node_grid, _node_sets, _weight_map, _tile_map, _solids, _fsl, _trees, _inside, _lights, _spawns)
	_attacking_spawn_x, _attacking_spawn_y = random.choice(list(_spawns['attacking']))
	_attacking_spawn_positions = [(x, y) for x, y in shapes.circle(_attacking_spawn_x, _attacking_spawn_y, 5) if not (x, y) in _solids]
	
	for squad_id in attacking_squads:
		_squad = entities.get_entity(squad_id)
		
		for member_id in _squad['members']:
			_member = entities.get_entity(member_id)
			_spawn_x, _spawn_y = _attacking_spawn_positions.pop(random.randint(0, len(_attacking_spawn_positions) - 1))
			
			entities.trigger_event(_member, 'set_position', x=_spawn_x, y=_spawn_y)
	
	_defending_spawn_x, _defending_spawn_y = random.choice(list(_spawns['defending']))
	_attacking_spawn_positions = [(x, y) for x, y in shapes.circle(_defending_spawn_x, _defending_spawn_y, 5) if not (x, y) in _solids]
	
	for squad_id in defending_squads:
		_squad = entities.get_entity(squad_id)
		
		for member_id in _squad['members']:
			_member = entities.get_entity(member_id)
			_spawn_x, _spawn_y = _attacking_spawn_positions.pop(random.randint(0, len(_attacking_spawn_positions) - 1))
			
			entities.trigger_event(_member, 'set_position', x=_spawn_x, y=_spawn_y)

	zones.activate(_zone)
	
	FADER = entities.create_entity()
	timers.register(FADER)
	fade_in()
	
	display.blit_background('tiles')
	
	while loop():
		events.trigger_event('cleanup')
Esempio n. 21
0
def bullet(entity, x, y, tx, ty, speed, accuracy, damage):
	_entity = _create(x, y, 'Bullet', '.', 0, 'bullet')
	_entity['owner'] = entity['_id']
	_entity['start_position'] = (x, y)
	_entity['end_position'] = (tx, ty)
	_entity['speed'] = speed
	_entity['damage'] = damage
	
	entities.add_entity_to_group(_entity, 'bullets')
	timers.register(_entity)
	
	entities.trigger_event(_entity, 'set_direction', direction=numbers.direction_to((x, y), (tx, ty))+random.uniform(-accuracy, accuracy))
	entities.trigger_event(_entity, 'create_timer', time=speed, repeat=-1, enter_callback=_bullet_tick, repeat_callback=_bullet_tick)
	entities.register_event(_entity, 'position_changed', lambda e, **kwargs: check_for_collisions(e))
	entities.register_event(_entity, 'collision_with_entity', lambda e, target_id: entities.trigger_event(entities.get_entity(target_id), 'hit', projectile=e))
	entities.register_event(_entity, 'collision_with_entity', lambda e, target_id: entities.delete_entity(e))
	entities.register_event(_entity, 'collision_with_solid', lambda e: effects.light(movement.get_position(e)[0], movement.get_position(e)[1], random.randint(3, 4)))
	entities.register_event(_entity, 'collision_with_solid', lambda e: entities.delete_entity(e))
	entities.register_event(_entity, 'collision_with_solid', lambda e: effects.smoke_cloud(movement.get_position(e)[0], movement.get_position(e)[1], random.uniform(2, 2.75), start_alpha=random.uniform(0.45, .65), decay_amount=1.5))
	entities.register_event(_entity, 'check_next_position', check_next_position)
	
	if not '--no-fx' in sys.argv:
		entities.register_event(_entity, 'position_changed', lambda e, x, y, **kwargs: _bullet_effects(e, x, y))
Esempio n. 22
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. 23
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. 24
0
def _start_battle(attacking_squads=[], defending_squads=[]):
    global FADER

    create()

    _width, _height, _node_grid, _node_sets, _weight_map, _tile_map, _solids, _fsl, _trees, _inside, _lights, _spawns = mapgen_arena.generate(
        200, 200)
    _zone = zones.create('swamps', _width, _height, _node_grid, _node_sets,
                         _weight_map, _tile_map, _solids, _fsl, _trees,
                         _inside, _lights, _spawns)
    _attacking_spawn_x, _attacking_spawn_y = random.choice(
        list(_spawns['attacking']))
    _attacking_spawn_positions = [
        (x, y)
        for x, y in shapes.circle(_attacking_spawn_x, _attacking_spawn_y, 5)
        if not (x, y) in _solids
    ]

    for squad_id in attacking_squads:
        _squad = entities.get_entity(squad_id)

        for member_id in _squad['members']:
            _member = entities.get_entity(member_id)
            _spawn_x, _spawn_y = _attacking_spawn_positions.pop(
                random.randint(0,
                               len(_attacking_spawn_positions) - 1))

            entities.trigger_event(_member,
                                   'set_position',
                                   x=_spawn_x,
                                   y=_spawn_y)

    _defending_spawn_x, _defending_spawn_y = random.choice(
        list(_spawns['defending']))
    _attacking_spawn_positions = [
        (x, y)
        for x, y in shapes.circle(_defending_spawn_x, _defending_spawn_y, 5)
        if not (x, y) in _solids
    ]

    for squad_id in defending_squads:
        _squad = entities.get_entity(squad_id)

        for member_id in _squad['members']:
            _member = entities.get_entity(member_id)
            _spawn_x, _spawn_y = _attacking_spawn_positions.pop(
                random.randint(0,
                               len(_attacking_spawn_positions) - 1))

            entities.trigger_event(_member,
                                   'set_position',
                                   x=_spawn_x,
                                   y=_spawn_y)

    zones.activate(_zone)

    FADER = entities.create_entity()
    timers.register(FADER)
    fade_in()

    display.blit_background('tiles')

    while loop():
        events.trigger_event('cleanup')
Esempio n. 25
0
def boot():
    _entity = entities.create_entity("systems")

    timers.register(_entity, use_system_event="logic")
Esempio n. 26
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. 27
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. 28
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. 29
0
File: ai.py Progetto: penny64/r3-tdw
def boot():
    _entity = entities.create_entity('systems')

    timers.register(_entity, use_system_event='logic')
Esempio n. 30
0
def create():
    global MAP, FADER

    worlds.create('strategy')
    words.reset()

    display.create_surface('background')
    display.create_surface('map',
                           width=constants.STRAT_MAP_WIDTH,
                           height=constants.STRAT_MAP_HEIGHT)
    display.create_surface('map_markers',
                           width=constants.STRAT_MAP_WIDTH,
                           height=constants.STRAT_MAP_HEIGHT)
    display.create_surface('map_squads',
                           width=constants.STRAT_MAP_WIDTH,
                           height=constants.STRAT_MAP_HEIGHT)
    display.create_surface('map_path',
                           width=constants.STRAT_MAP_WIDTH,
                           height=constants.STRAT_MAP_HEIGHT)
    display.create_surface('ui_bar',
                           width=constants.WINDOW_WIDTH,
                           height=constants.WINDOW_HEIGHT -
                           constants.STRAT_MAP_HEIGHT)
    display.fill_surface('ui_bar', (30, 30, 30))
    display.blit_background('background')

    register_input()

    entities.create_entity_group('life', static=True)
    entities.create_entity_group('items', static=True)
    entities.create_entity_group('factions', static=True)
    entities.create_entity_group('squads', static=True)
    entities.create_entity_group('systems')

    FADER = entities.create_entity()
    timers.register(FADER)
    fade_in()

    _grid = {}
    _color_map = {}

    MAP = {
        'grid':
        _grid,
        'color_map':
        _color_map,
        'astar_map':
        None,
        'astar_weight_map':
        numpy.ones((constants.STRAT_MAP_HEIGHT / constants.MAP_CELL_SPACE,
                    constants.STRAT_MAP_WIDTH / constants.MAP_CELL_SPACE))
    }

    for x in range(constants.STRAT_MAP_WIDTH / constants.MAP_CELL_SPACE):
        for y in range(constants.STRAT_MAP_HEIGHT / constants.MAP_CELL_SPACE):
            _grid[x, y] = {
                'owned_by': None,
                'is_ownable': False,
                'squads': [],
                'income': .025
            }

    worldgen.generate()

    unregister_input()
    world_action._start_battle(
        attacking_squads=[entities.get_entity_group('squads')[0]],
        defending_squads=[entities.get_entity_group('squads')[1]])