示例#1
0
def tick_eyemine(entity):
	if 'max_explode_velocity' in entity and entity['current_speed']>=entity['max_explode_velocity']:
		entities.trigger_event(entity, 'kill')
		entities.trigger_event(entity, 'explode')
		
		return entities.delete_entity(entity)
	
	if entity['current_target'] and entity['current_target'] in entities.ENTITIES:
		_target_object = entities.get_entity(entity['current_target'])
	else:
		_target_object = None
	
	for soldier_id in entities.get_sprite_groups(['enemies', 'players']):
		if entity['_id'] == soldier_id:
			continue
		
		if numbers.distance(entity['position'], entities.get_entity(soldier_id)['position'], old=True)>50:
			continue
		
		if _target_object and not entity['current_target'] == soldier_id and 'player' in _target_object:
			entities.trigger_event(_target_object,
			                       'score',
			                       target_id=entity['_id'],
			                       amount=10,
			                       text='Creative Escape')
		
		entities.trigger_event(entities.get_entity(soldier_id), 'hit', damage=6, target_id=entity['_id'])
		entities.trigger_event(entity, 'kill')
		entities.trigger_event(entity, 'explode')
		entities.delete_entity(entity)
		
		break
示例#2
0
def tick(entity):
	entity['recoil_time'] -= 1
	
	if not entity['owner_id'] in entities.ENTITIES:
		entities.unregister_event(entity, 'tick', tick)
		
		return False
	
	if entity['recoil_time']>0:
		return False
	elif not entity['rounds']:
		if entity['reload_time']:
			if entity['owner_id'] in entities.ENTITIES and 'player' in entities.get_entity(entity['owner_id']) and entity['reload_time'] == entity['reload_time_max']:
				display.print_text(0, 0, 'RELOADING', show_for=(entity['reload_time']/display.get_tps())*2, fade_out_speed=255)
				
			entity['reload_time'] -= 1
		else:
			entity['reload_time'] = entity['reload_time_max']
			entity['recoil_time'] = 1
			entity['rounds'] = entity['max_rounds']
			entity['firing'] = False
			entities.unregister_event(entity, 'tick', tick)
		
		return False
	
	_owner = entities.get_entity(entity['owner_id'])
	
	if 'shoot_direction' in entity:
		_direction = entity['shoot_direction']
	elif 'shoot_direction' in _owner:
		_direction = _owner['shoot_direction']
	else:
		_direction = _owner['direction']
	
	if entity['kickback']:
		entities.trigger_event(entities.get_entity(entity['owner_id']), 'push', velocity=numbers.velocity(_direction+180, entity['kickback']))
	
	if entity['missile']:
		bullet.create_missile(_owner['position'][0],
		                      _owner['position'][1],
		                      _direction,
		                      entity['speed'],
		                      'bullet.png',
		                      entity['owner_id'],
		                      turn_rate=entity['turn_rate'],
		                      tracking=entity['tracking'],
		                      radius=entity['damage_radius'])
	
	if entity['bullet']:
		bullet.create_bullet(_owner['position'][0],
		                     _owner['position'][1],
		                     _direction+random.randint(-entity['spray'], entity['spray']),
		                     entity['speed'],
		                     'bullet.png',
		                     entity['owner_id'],
		                     scale=.6,
		                     radius=entity['damage_radius'])
	
	entity['recoil_time'] = entity['recoil_time_max']
	entity['rounds'] -= 1
示例#3
0
def handle_camera(entity_id, min_zoom=3.5, max_zoom=14.5, max_enemy_distance=2400, center_distance=600.0):
	if not entity_id in entities.ENTITIES:
		display.CAMERA['zoom_speed'] = .005
		display.CAMERA['next_zoom'] = 4.5
		
		return False
	
	if not clock.is_ticking():
		return False
	
	_player = entities.get_entity(entity_id)
	_center_pos = _player['position'].copy()
	_median_distance = []
	
	if 'in_space' in _player and _player['in_space']:
		_distance_to_center = numbers.distance(_player['position'], (worlds.get_size()[0]/2, worlds.get_size()[1]/2))
		
		_min_zoom = 2.0
		_max_zoom = max_zoom
		display.CAMERA['next_zoom'] = numbers.clip(_max_zoom*((_distance_to_center/3000.0)-1), _min_zoom, _max_zoom)
	
	elif _player['death_timer'] == -1:
		for enemy_id in entities.get_sprite_groups(['enemies', 'hazards']):
			_enemy = entities.get_entity(enemy_id)
			
			if 'player' in _enemy:
				continue
			
			_dist = numbers.distance(_player['position'], _enemy['position'])
			if _dist>=max_enemy_distance:
				continue
			
			_median_distance.append(_dist)
			_center_pos = numbers.interp_velocity(_center_pos, _enemy['position'], 0.5)
		
		if not _median_distance:
			_median_distance = [0]
		
		_distance_to_nearest_enemy = sum(_median_distance)/len(_median_distance)
		_min_zoom = min_zoom
		_max_zoom = max_zoom
		display.CAMERA['next_zoom'] = numbers.clip(_max_zoom*(_distance_to_nearest_enemy/float(center_distance)), _min_zoom, _max_zoom)
	else:
		display.CAMERA['zoom_speed'] = .05
		display.CAMERA['next_zoom'] = 1.5
	
	if display.CAMERA['next_zoom'] < 5:
		display.CAMERA['next_center_on'] = _center_pos
	else:
		display.CAMERA['next_center_on'] = _player['position'].copy()
示例#4
0
def hit_laser(bullet, target_id):
	for i in range(random.randint(2, 3)):
		_effect = effects.create_particle(bullet['position'][0]+random.randint(-6, 6),
		                                  bullet['position'][1]+random.randint(-6, 6),
		                                  'explosion.png',
		                                  background=False,
		                                  scale=random.uniform(.4, .8),
		                                  flashes=random.randint(15, 25),
		                                  flash_chance=0.7)
		
		_effect['velocity'] = numbers.interp_velocity(bullet['velocity'], entities.get_entity(target_id)['velocity'], .1)
		_effect['velocity'][0] = numbers.clip(_effect['velocity'][0], -6, 6)
		_effect['velocity'][1] = numbers.clip(_effect['velocity'][1], -6, 6)
	
	entities.trigger_event(entities.get_entity(target_id), 'accelerate', velocity=numbers.interp_velocity(entities.get_entity(target_id)['velocity'], bullet['velocity'], .4))
示例#5
0
def create_ping_checks_public_aliases(entity_id):
    """Create ping checks on all interfaces for an entity."""
    
    e = get_entity(entity_id)
    for alias in e['ip_addresses']:
        if 'public' in alias:
            create_ping_check(e['id'], alias)
示例#6
0
def tick_track(entity):
	#_target_id = find_target(entity)
	_target_id = entity['current_target']
	
	if 'in_space' in entity and entity['in_space']:
		return False
	
	if entity['hp']<=0 or not _target_id in entities.ENTITIES:
		entity['current_target'] = None
		entities.unregister_event(entity, 'tick', tick_track)
		
		return False
	
	if not _target_id:
		entities.trigger_event(entity, 'accelerate', velocity=(0, 0))
		
		return False
	
	_target = entities.get_entity(_target_id)
	_direction_to = numbers.direction_to(entity['position'], _target['position'])
	_degrees_to = abs(entity['direction']-_direction_to)
	
	if _degrees_to>=180:
		_direction_to += 360
	
	_new_direction = numbers.interp(entity['direction'], _direction_to, entity['turn_rate'])
	_direction_difference = abs(entity['direction']-_new_direction)
	entity['direction'] = _new_direction
	entities.trigger_event(entity, 'thrust')
示例#7
0
def create_flea(x=0, y=0, hazard=False):
	if hazard:
		_group = 'hazards'
	else:
		_group = 'enemies'
	
	_entity = create(sprite_name='diamond_body.png', group=_group, x=x, y=y, acceleration=.4, speed=30, max_velocity=30, turn_rate=0.8)
	_entity['current_target'] = None
	_entity['fire_rate'] = 0
	_entity['fire_rate_max'] = 20
	_entity['weapon_id'] = weapons.create(_entity['_id'], rounds=3, recoil_time=15, speed=30, tracking=False)['_id']
	
	effects.create_image(_entity['position'][0],
	                     _entity['position'][1],
	                     'diamond_turret.png',
	                     parent_entity=_entity)
	effects.create_image(_entity['position'][0],
	                     _entity['position'][1],
	                     'diamond_drive.png',
	                     parent_entity=_entity,
	                     rotate_by=3)
	
	entities.register_event(_entity, 'moved', set_direction)
	entities.register_event(_entity, 'tick', tick_energy_ship)
	entities.register_event(_entity, 'tick', tick_flea)
	entities.register_event(_entity, 'tick', tick_turret)
	entities.register_event(_entity, 'shoot', lambda entity: entities.trigger_event(entities.get_entity(_entity['weapon_id']), 'shoot'))
	
	return _entity
示例#8
0
def create(owner_id, rounds=1, recoil_time=16, reload_time=35, kickback=0, spray=8, turn_rate=.15, speed=30, bullet=False, missile=True, hitscan=False, tracking=False, damage_radius=50):
	_entity = entities.create_entity(group='weapons')
	_entity['owner_id'] = owner_id
	_entity['rounds'] = rounds
	_entity['max_rounds'] = rounds
	_entity['recoil_time'] = 1
	_entity['recoil_time_max'] = recoil_time
	_entity['reload_time'] = reload_time
	_entity['reload_time_max'] = reload_time
	_entity['bullet'] = bullet
	_entity['missile'] = missile
	_entity['hitscan'] = hitscan
	_entity['tracking'] = tracking
	_entity['firing'] = False
	_entity['turn_rate'] = turn_rate
	_entity['speed'] = speed
	_entity['damage_radius'] = damage_radius
	_entity['kickback'] = kickback
	_entity['spray'] = spray
	
	entities.create_event(_entity, 'shoot')
	entities.register_event(_entity, 'shoot', shoot)
	entities.register_event(entities.get_entity(owner_id), 'delete', lambda owner_entity: entities.delete_entity(_entity))
	
	return _entity
示例#9
0
文件: ai.py 项目: penny64/vector-kill
def tick_track(entity):
    #_target_id = find_target(entity)
    _target_id = entity['current_target']

    if 'in_space' in entity and entity['in_space']:
        return False

    if entity['hp'] <= 0 or not _target_id in entities.ENTITIES:
        entity['current_target'] = None
        entities.unregister_event(entity, 'tick', tick_track)

        return False

    if not _target_id:
        entities.trigger_event(entity, 'accelerate', velocity=(0, 0))

        return False

    _target = entities.get_entity(_target_id)
    _direction_to = numbers.direction_to(entity['position'],
                                         _target['position'])
    _degrees_to = abs(entity['direction'] - _direction_to)

    if _degrees_to >= 180:
        _direction_to += 360

    _new_direction = numbers.interp(entity['direction'], _direction_to,
                                    entity['turn_rate'])
    _direction_difference = abs(entity['direction'] - _new_direction)
    entity['direction'] = _new_direction
    entities.trigger_event(entity, 'thrust')
示例#10
0
def loop():
	global CHANGE_WAVE_FIRE, TRANSITION_PAUSE, CHANGE_WAVE, WAVE_TIMER, LEVEL, WAVE
	
	if TRANSITION_PAUSE and CHANGE_WAVE:
		_player = entities.get_entity(entities.get_entity_group('players')[0])
		
		if not CHANGE_WAVE_FIRE:
			entities.trigger_event(_player,
			                       'create_timer',
			                       time=120,
			                       enter_callback=lambda entity: events.unregister_event('input', player.handle_input),
			                       callback=lambda entity: entities.trigger_event(entity, 'push', velocity=(6, 6)),
			                       exit_callback=lambda entity: display.camera_snap((-4000, -4000)) and entities.trigger_event(entity, 'set_position', x=-4000, y=-4000) and events.register_event('input', player.handle_input, _player['_id']) and create_planet())
			
			LEVEL += 1
			_player['NO_BOUNCE'] = True
			CHANGE_WAVE_FIRE = True
		
		if TRANSITION_PAUSE:
			TRANSITION_PAUSE -= 1
		
		return False
	
	if CHANGE_WAVE:
		WAVE = 1
		CHANGE_WAVE = False
	
	if not entities.get_entity_group('enemies') and not entities.get_entity_group('hazards') and WAVE_TIMER:
		WAVE_TIMER -= 4
	
	if entities.get_entity_group('players') and WAVE_TIMER<=0 or (LEVEL == 2 and not entities.get_entity_group('enemies')):
		spawn_enemies()
		WAVE_TIMER = WAVE_TIMER_MAX+(60*WAVE)
示例#11
0
def create_missile_turret(x=0, y=0):
	_entity = create(x=x, y=y, group='hazards', sprite_name='eyemine_body.png', speed=5, acceleration=1, max_velocity=5)
	_entity['weapon_id'] = weapons.create(_entity['_id'], rounds=3, recoil_time=20, tracking=True, turn_rate=.02)['_id']
	
	entities.register_event(_entity, 'shoot', lambda entity: entities.trigger_event(entities.get_entity(_entity['weapon_id']), 'shoot'))
	entities.register_event(_entity, 'tick', tick_turret)
	
	return _entity
示例#12
0
def tick_image(image):
	if image['parent_entity']:
		_parent_entity = entities.get_entity(image['parent_entity'])
		entities.trigger_event(image, 'set_position', x=_parent_entity['position'][0], y=_parent_entity['position'][1])
		
		if image['rotate_with_parent']:
			entities.trigger_event(image, 'set_rotation', degrees=_parent_entity['direction'])
		elif image['rotate_by']:
			entities.trigger_event(image, 'rotate_by', degrees=image['rotate_by'])
示例#13
0
def create_bullet(x, y, direction, speed, sprite_name, owner_id, damage=3, life=3000, scale=.2, radius=50):
	_bullet = create(x, y, direction, speed, sprite_name, owner_id, damage=damage, life=life)
	_owner = entities.get_entity(_bullet['owner_id'])
	_bullet['sprite'].anchor_x = 0
	_bullet['sprite'].anchor_y = sprites.get_size(_bullet['sprite'])[1]/2
	
	entities.trigger_event(_bullet, 'set_scale', scale=scale)
	entities.trigger_event(_bullet, 'set_rotation', degrees=_bullet['direction'])
	
	return _bullet
示例#14
0
def damage(entity, damage, target_id=None):
	entity['hp'] -= damage
	
	if entity['hp']<=0 and entity['death_timer'] == -1:
		entities.trigger_event(entity, 'set_friction', friction=0.05)
		
		if target_id in entities.ENTITIES:
			entities.trigger_event(entities.get_entity(target_id),
			                       'score',
			                       target_id=entity['_id'],
			                       amount=5,
			                       text='Kill')
	elif entity['hp']<0:
		_text = 'Overkill'
		
		if target_id in entities.ENTITIES:
			entities.trigger_event(entities.get_entity(target_id),
			                       'score',
			                       target_id=entity['_id'],
			                       amount=2*abs(entity['hp']),
			                       text=_text)
示例#15
0
def create_missile(x, y, direction, speed, sprite_name, owner_id, life=3000, scale=.2, turn_rate=.15, tracking=True, drunk=True, radius=50):
	_bullet = create(x, y, direction, speed, sprite_name, owner_id, life=life, turn_rate=turn_rate, radius=radius)
	_owner = entities.get_entity(_bullet['owner_id'])
	_bullet['sprite'].anchor_x = 0
	_bullet['sprite'].anchor_y = sprites.get_size(_bullet['sprite'])[1]/2
	
	entities.trigger_event(_bullet, 'set_scale', scale=scale)
	entities.register_event(_bullet, 'tick', tick_missile)
	entities.register_event(_bullet, 'hit', hit_missile)
	
	if drunk:
		entities.register_event(_bullet, 'tick', tick_drunk)
	
	if tracking:
		_bullet['target_id'] = ai.find_target(_owner, max_distance=1600)
		
		if _bullet['target_id']:
			_target = entities.get_entity(_bullet['target_id'])
			
			entities.register_event(_bullet, 'tick', tick_track)
			entities.register_event(_target,
			                        'delete',
			                        lambda target: _bullet['_id'] in entities.ENTITIES and entities.unregister_event(_bullet,
			                                                                                                         'tick',
			                                                                                                         tick_track))
			
			if 'player' in _owner and _owner['player']:
				effects.create_particle(_target['position'][0],
					                    _target['position'][1],
					                    'crosshair.png',
					                    background=False,
					                    scale_rate=.95,
					                    fade_rate=.98,
					                    spin=random.choice([-3, -6, 3, 6]))
	else:
		_bullet['target_id'] = None
	
	_bullet['engine_power'] = 100
	
	return _bullet
示例#16
0
def tick_track(bullet):
	if bullet['target_id']:
		_target = entities.get_entity(bullet['target_id'])
		_current_direction = bullet['direction']
		_direction_to = numbers.direction_to(bullet['position'], _target['position'])
		_degrees_to = _current_direction-_direction_to
		
		if (_degrees_to > 0 and abs(_degrees_to) <= 180) or (_degrees_to < 0 and abs(_degrees_to) > 180):
			bullet['direction'] -= 12
		elif (_degrees_to > 0 and abs(_degrees_to) > 180) or (_degrees_to < 0 and abs(_degrees_to) <= 180):
			bullet['direction'] += 12
		
		entities.trigger_event(bullet, 'thrust')
示例#17
0
def tick(bullet):
	for soldier_id in entities.get_sprite_groups(bullet['enemy_sprite_groups']):
		if bullet['owner_id'] == soldier_id:
			continue
		
		_entity = entities.get_entity(soldier_id)
		
		if numbers.distance(bullet['position'], _entity['position'], old=True)-_entity['collision_radius']>bullet['damage_radius']:
			continue
		
		if bullet['owner_id'] in entities.ENTITIES and 'player' in entities.get_entity(bullet['owner_id']):
			effects.create_particle(bullet['position'][0],
				                   bullet['position'][1],
				                   'hitmarker.png',
				                   direction=random.randint(0, 359),
				                   speed=random.randint(25, 30),
				                   background=False,
				                   fade_rate=0.8,
			                        scale_rate=1.02)
		
		entities.trigger_event(bullet, 'hit', target_id=soldier_id)
		entities.trigger_event(_entity, 'hit', damage=bullet['damage'], target_id=bullet['owner_id'])
		entities.delete_entity(bullet)
示例#18
0
def create_gun_turret(x=0, y=0):
	_entity = create(x=x, y=y, group='hazards', sprite_name='eyemine_body.png', speed=5, acceleration=1, max_velocity=5)
	_entity['weapon_id'] = weapons.create(_entity['_id'],
	                                      rounds=10,
	                                      recoil_time=2,
	                                      reload_time=40,
	                                      damage_radius=40,
	                                      speed=140,
	                                      missile=False,
	                                      bullet=True)['_id']
	
	entities.register_event(_entity, 'shoot', lambda entity: entities.trigger_event(entities.get_entity(_entity['weapon_id']), 'shoot'))
	entities.register_event(_entity, 'tick', tick_turret)
	
	return _entity
示例#19
0
def _gravity_well(entity):
	_moving_groups = [name for name in entities.GROUPS if not name in entity['_groups'] and not name in entities.IGNORE_ENTITY_GROUPS]
	
	for entity_id in entities.get_sprite_groups(_moving_groups):
		_entity = entities.get_entity(entity_id)
		
		if numbers.distance(entity['position'], _entity['position'])<entity['min_distance']:
			_entity['in_space'] = False
			
			continue
		
		if entity['kill_engines']:
			_entity['in_space'] = True
		
		_velocity = numbers.velocity(numbers.direction_to(_entity['position'], entity['position']), entity['strength'])
		
		entities.trigger_event(_entity, 'push', velocity=_velocity)
示例#20
0
def find_target(entity, max_distance=-1):
	_closest_target = {'enemy_id': None, 'distance': 0}
	_enemy_sprite_groups = [name for name in entities.GROUPS if not name in entity['_groups'] and not name in entities.IGNORE_ENTITY_GROUPS]
	
	for soldier_id in entities.get_sprite_groups(_enemy_sprite_groups):
		if entity['_id'] == soldier_id:
			continue
		
		_distance = numbers.distance(entity['position'], entities.get_entity(soldier_id)['position'])
		
		if max_distance>-1 and _distance>max_distance:
			continue
		
		if not _closest_target['enemy_id'] or _distance<_closest_target['distance']:
			_closest_target['distance'] = _distance
			_closest_target['enemy_id'] = soldier_id
	
	return _closest_target['enemy_id']
示例#21
0
def on_mouse_press(x, y, button, modifiers):
	_x, _y = int(round(CURSOR['position'][0])), int(round(CURSOR['position'][1]))
	_chunk_key = get_chunk_key_at(int(round(CURSOR['position'][0])), int(round(CURSOR['position'][1])))
	
	MOUSE_BUTTONS[button] = 1
	
	if button == 1 and not MAP[_chunk_key]['solid']:
		_tile = entities.create_entity(group='tiles_foreground')
		sprites.register_entity(_tile, 'tiles_foreground', 'wall_full.png')
		movement.register_entity(_tile, x=(_x/100)*100, y=(_y/100)*100)
		_tile['sprite'].image.anchor_x = 0
		_tile['sprite'].image.anchor_y = 0
		
		MAP[_chunk_key]['solid'] = True
		MAP[_chunk_key]['tile'] = _tile['_id']
	elif button == 4 and MAP[_chunk_key]['solid']:
		MAP[_chunk_key]['solid'] = False
		entities.delete_entity(entities.get_entity(MAP[_chunk_key]['tile']))
		del MAP[_chunk_key]['tile']
示例#22
0
文件: ai.py 项目: penny64/vector-kill
def tick_guard(entity):
    if 'in_space' in entity and entity['in_space']:
        return False

    if entity['hp'] <= 0:
        entities.unregister_event(entity, 'tick', tick_guard)

        return False

    if not entity['current_target']:
        _target_id = find_target(entity, max_distance=350)

        if _target_id:
            entities.trigger_event(
                entity,
                'set_direction',
                direction=numbers.direction_to(
                    entity['position'],
                    entities.get_entity(_target_id)['position']))
            track_target(entity, _target_id)
示例#23
0
def create_energy_ship(x=0, y=0):
	_entity = create(x=x, y=y, group='players', sprite_name='ball.png', speed=19, acceleration=.3, max_velocity=30, turn_rate=0.5, death_time=35, hp=60)
	_entity['weapon_id'] = weapons.create(_entity['_id'],
	                                      rounds=35,
	                                      recoil_time=0,
	                                      reload_time=48,
	                                      kickback=3,
	                                      damage_radius=65,
	                                      spray=3,
	                                      speed=200,
	                                      missile=False,
	                                      bullet=True)['_id']
	_entity['alt_weapon_id'] = weapons.create(_entity['_id'], rounds=6, recoil_time=5, reload_time=28, speed=60, tracking=True)['_id']
	
	timers.register_entity(_entity)
	entities.register_event(_entity, 'tick', tick_energy_ship)
	entities.register_event(_entity, 'shoot', lambda entity, direction=0: entities.trigger_event(entities.get_entity(_entity['weapon_id']), 'shoot', direction=direction))
	entities.register_event(_entity, 'shoot_alt', lambda entity: entities.trigger_event(entities.get_entity(_entity['alt_weapon_id']), 'shoot'))
	
	return _entity
示例#24
0
def action_camera():
	global CAMERA_TIME, CAMERA_MODE
	
	if CAMERA_MODE == 'hover':
		display.CAMERA['next_center_on'] = numpy.array([worlds.get_size()[0]/2, worlds.get_size()[1]/2])
		display.CAMERA['next_zoom'] = 5.0
	
	elif CAMERA_MODE == 'follow':
		_focus_on = entities.get_entity_group('enemies')
		
		if not _focus_on:
			_focus_on = entities.get_entity_group('hazards')
		
		display.CAMERA['next_center_on'] = entities.get_entity(_focus_on[0])['position'].copy()
		display.CAMERA['next_zoom'] = 2.5
	
	CAMERA_TIME -= 1
	
	if not CAMERA_TIME:
		CAMERA_MODE = random.choice(CAMERA_MODES)
		CAMERA_TIME = random.randint(120, 200)
示例#25
0
def create(x, y, direction, speed, sprite_name, owner_id, damage=3, life=30, turn_rate=.15, radius=50):
	_entity = entities.create_entity()
	
	movement.register_entity(_entity, x=x, y=y, direction=direction, speed=speed, turn_rate=turn_rate)
	sprites.register_entity(_entity, 'effects_foreground', sprite_name)
	entities.create_event(_entity, 'hit')
	entities.create_event(_entity, 'destroy')
	entities.register_event(_entity, 'tick', tick)
	entities.register_event(_entity, 'tick', tick_bullet)
	entities.register_event(_entity, 'destroy', destroy)
	entities.register_event(_entity, 'hit_edge', lambda entity: entities.trigger_event(entity, 'destroy'))
	entities.trigger_event(_entity, 'set_friction', friction=0)
	entities.trigger_event(_entity, 'thrust')
	entities.add_entity_to_group('bullets', _entity)
	
	_entity['life'] = life
	_entity['owner_id'] = owner_id
	_entity['damage'] = damage
	_entity['damage_radius'] = radius
	_entity['enemy_sprite_groups'] = [name for name in entities.GROUPS if not name in entities.get_entity(_entity['owner_id'])['_groups'] and not name in entities.IGNORE_ENTITY_GROUPS]
	
	return _entity
示例#26
0
def create_ivan(x=0, y=0):
	_entity = create(sprite_name='boss1.png', group='enemies', x=x, y=y, acceleration=.4, speed=3, max_velocity=3, turn_rate=0.8, death_time=40, hp=100)
	_entity['current_target'] = None
	_entity['fire_rate'] = 0
	_entity['fire_rate_max'] = 20
	_entity['weapon_id'] = weapons.create(_entity['_id'],
	                                      rounds=25,
	                                      recoil_time=1,
	                                      reload_time=30,
	                                      damage_radius=40,
	                                      speed=140,
	                                      missile=False,
	                                      bullet=True)['_id']
	
	entities.register_event(_entity, 'moved', set_direction)
	entities.register_event(_entity, 'tick', tick_energy_ship)
	entities.register_event(_entity, 'tick', tick_flea)
	entities.register_event(_entity, 'tick', tick_turret)
	entities.register_event(_entity, 'kill', boss_victory)
	entities.register_event(_entity, 'dying', boss_dying)
	entities.register_event(_entity, 'explode', boss_explode)
	entities.register_event(_entity, 'shoot', lambda entity: entities.trigger_event(entities.get_entity(_entity['weapon_id']), 'shoot'))
	
	return _entity
示例#27
0
文件: ai.py 项目: penny64/vector-kill
def find_target(entity, max_distance=-1):
    _closest_target = {'enemy_id': None, 'distance': 0}
    _enemy_sprite_groups = [
        name for name in entities.GROUPS if not name in entity['_groups']
        and not name in entities.IGNORE_ENTITY_GROUPS
    ]

    for soldier_id in entities.get_sprite_groups(_enemy_sprite_groups):
        if entity['_id'] == soldier_id:
            continue

        _distance = numbers.distance(
            entity['position'],
            entities.get_entity(soldier_id)['position'])

        if max_distance > -1 and _distance > max_distance:
            continue

        if not _closest_target[
                'enemy_id'] or _distance < _closest_target['distance']:
            _closest_target['distance'] = _distance
            _closest_target['enemy_id'] = soldier_id

    return _closest_target['enemy_id']
示例#28
0
def score(entity, target_id, amount=0, text=''):
	display.print_text(0, 10+(len(display.LABELS)*15), '%s (<b>+%s</b>)' % (text, amount), color=(0, 240, 0, 255), show_for=1.5)
	
	if target_id in entities.ENTITIES and abs(entity['shoot_direction']-numbers.direction_to(entity['position'], entities.get_entity(target_id)['position']))<45:
		display.print_text(0, 10+(len(display.LABELS)*15), 'FRENZY!!!', color=(0, 240, 0, 255), show_for=1.5)
示例#29
0
def tick_turret(entity):
	_target_id = ai.find_target(entity, max_distance=1600)
	
	if _target_id:
		entity['shoot_direction'] = numbers.direction_to(entity['position'], entities.get_entity(_target_id)['position'])
		entities.trigger_event(entity, 'shoot')
示例#30
0
def create_eyemine(x=0, y=0, max_explode_velocity=40):
	_entity = create(x=x, y=y, group='hazards', sprite_name='eyemine_body.png', speed=35, acceleration=0.1, max_velocity=35)
	_entity['max_explode_velocity'] = max_explode_velocity
	
	effects.create_image(_entity['position'][0],
	                     _entity['position'][1],
	                     'eyemine_subbody.png',
	                     parent_entity=_entity,
	                     rotate_by=3,
	                     background=True)
	effects.create_image(_entity['position'][0],
	                     _entity['position'][1],
	                     'eyemine_eye1.png',
	                     parent_entity=_entity,
	                     background=False)
	effects.create_image(_entity['position'][0],
	                     _entity['position'][1],
	                     'eyemine_eye2.png',
	                     parent_entity=_entity,
	                     rotate_with_parent=True,
	                     background=False)
	entities.register_event(_entity, 'tick', tick_eyemine)
	entities.register_event(_entity,
	                        'hit',
	                        lambda _entity, target_id, **kwargs: target_id in entities.ENTITIES and entities.trigger_event(_entity,
	                                                                                                                       'set_direction',
	                                                                                                                       direction=numbers.direction_to(_entity['position'],
	                                                                                                                                                      entities.get_entity(target_id)['position'])))
	entities.register_event(_entity, 'hit', lambda _entity, target_id, **kwargs: ai.track_target(_entity, target_id))
	entities.register_event(_entity, 'hit_edge', lambda entity: entities.trigger_event(entity, 'kill'))
	ai.guard(_entity)
	
	return _entity
示例#31
0
def handle_input(entity_id):
	if not entity_id in entities.ENTITIES or not 'player' in entities.ENTITIES[entity_id]:
		if controls.key_pressed(' '):
			battlefield.clean()
			battlefield.create_player()
			battlefield.spawn_enemies()
		
		return False
	
	if not clock.is_ticking() and controls.key_pressed(' '):
		clock.hang_for(0)
	
	_entity = entities.get_entity(entity_id)
	_move_speed = _entity['speed']
	
	if controls.key_held('s'):
		#entities.trigger_event(_entity, 'accelerate', velocity=[0, _move_speed])
		entities.trigger_event(_entity, 'set_direction', direction=270)
		entities.trigger_event(_entity, 'thrust')
	
	if controls.key_held('a'):
		#entities.trigger_event(_entity, 'accelerate', velocity=[-_move_speed, 0])
		entities.trigger_event(_entity, 'set_direction', direction=180)
		entities.trigger_event(_entity, 'thrust')
	
	if controls.key_held('d'):
		#entities.trigger_event(_entity, 'accelerate', velocity=[_move_speed, 0])
		entities.trigger_event(_entity, 'set_direction', direction=0)
		entities.trigger_event(_entity, 'thrust')
	
	if controls.key_held('w'):
		#entities.trigger_event(_entity, 'accelerate', velocity=[0, -_move_speed])
		entities.trigger_event(_entity, 'set_direction', direction=90)
		entities.trigger_event(_entity, 'thrust')
	
	if controls.key_pressed('q'):
		entities.trigger_event(_entity,
		                       'create_timer',
		                       time=120,
		                       enter_callback=lambda entity: entities.trigger_event(_entity, 'set_maximum_velocity', velocity=[80, 80]) and entities.trigger_event(_entity, 'set_speed', speed=80),
		                       exit_callback=lambda entity: entities.trigger_event(_entity, 'set_maximum_velocity', velocity=[30, 30]))
	
	if controls.key_pressed('v'):
		for entity_id in entities.get_sprite_groups(['hazards', 'enemies']):
			entities.delete_entity_via_id(entity_id)
	
	if controls.key_held_ord(controls.NUM_1):
		entities.trigger_event(_entity, 'shoot', direction=225)
	
	if controls.key_held_ord(controls.NUM_2):
		entities.trigger_event(_entity, 'shoot', direction=270)
	
	if controls.key_held_ord(controls.NUM_3):
		entities.trigger_event(_entity, 'shoot', direction=315)
	
	if controls.key_held_ord(controls.NUM_4):
		entities.trigger_event(_entity, 'shoot', direction=180)
	
	if controls.key_held_ord(controls.NUM_6):
		entities.trigger_event(_entity, 'shoot', direction=0)
	
	if controls.key_held_ord(controls.NUM_7):
		entities.trigger_event(_entity, 'shoot', direction=135)
	
	if controls.key_held_ord(controls.NUM_8):
		entities.trigger_event(_entity, 'shoot', direction=90)
	
	if controls.key_held_ord(controls.NUM_9):
		entities.trigger_event(_entity, 'shoot', direction=45)
	
	if controls.key_held_ord(controls.NUM_5):
		entities.trigger_event(_entity, 'shoot_alt')
	
	if controls.key_held('x'):
		battlefield.clean()
示例#32
0
def tick_guard(entity):
	if 'in_space' in entity and entity['in_space']:
		return False
	
	if entity['hp']<=0:
		entities.unregister_event(entity, 'tick', tick_guard)
		
		return False
	
	if not entity['current_target']:
		_target_id = find_target(entity, max_distance=350)
		
		if _target_id:
			entities.trigger_event(entity, 'set_direction', direction=numbers.direction_to(entity['position'], entities.get_entity(_target_id)['position']))
			track_target(entity, _target_id)