예제 #1
0
def manage_hands(life):
    for item in [lfe.get_inventory_item(life, item) for item in lfe.get_held_items(life)]:
        judgement.judge_item(life, item["uid"])
        _known_item = brain.get_remembered_item(life, item["uid"])

        if _known_item["score"]:  # judgement.get_score_of_highest_scoring_item(life):
            continue

        _equip_action = {"action": "equipitem", "item": item["uid"]}

        if len(lfe.find_action(life, matches=[_equip_action])):
            return True

        if lfe.can_wear_item(life, item["uid"]):
            lfe.add_action(life, _equip_action, 401, delay=lfe.get_item_access_time(life, item["uid"]))
            return True

        _storage = lfe.can_put_item_in_storage(life, item["uid"])
        if not "CAN_WEAR" in item["flags"] and _storage:
            _store_action = {"action": "storeitem", "item": item["uid"], "container": _storage}

            if len(lfe.find_action(life, matches=[_store_action])):
                continue

            lfe.add_action(life, _store_action, 401, delay=lfe.get_item_access_time(life, item["uid"]))
            return True

    return False
예제 #2
0
def explore_unknown_chunks(life):
    if life['path']:
        return True

    _chunk_key = references.path_along_reference(life, 'roads')

    if not _chunk_key:
        return False

    _walkable_area = chunks.get_walkable_areas(_chunk_key)
    if not _walkable_area:
        print 'no walkable area'
        return False

    _closest_pos = {'pos': None, 'distance': -1}
    for pos in _walkable_area:
        _distance = numbers.distance(life['pos'], pos)

        if _distance <= 1:
            _closest_pos['pos'] = pos
            break

        if not _closest_pos['pos'] or _distance < _closest_pos['distance']:
            _closest_pos['pos'] = pos
            _closest_pos['distance'] = _distance

    lfe.clear_actions(life)
    lfe.add_action(life, {'action': 'move', 'to': _closest_pos['pos']}, 200)

    return True
예제 #3
0
파일: survival.py 프로젝트: flags/Reactor-3
def explore_unknown_chunks(life):
	if life['path']:
		return True
	
	_chunk_key = references.path_along_reference(life, 'roads')
	
	if not _chunk_key:
		return False
	
	_walkable_area = chunks.get_walkable_areas(_chunk_key)
	if not _walkable_area:
		print 'no walkable area'
		return False
	
	_closest_pos = {'pos': None, 'distance': -1}
	for pos in _walkable_area:
		_distance = bad_numbers.distance(life['pos'], pos)
				
		if _distance <= 1:
			_closest_pos['pos'] = pos
			break
		
		if not _closest_pos['pos'] or _distance<_closest_pos['distance']:
			_closest_pos['pos'] = pos
			_closest_pos['distance'] = _distance
	
	lfe.clear_actions(life)
	lfe.add_action(life,{'action': 'move','to': _closest_pos['pos']},200)
	
	return True
예제 #4
0
def pick_up_item(life, item_uid):
    _not_moved = travel_to_position(life, ITEMS[item_uid]["pos"])

    if _not_moved:
        lfe.add_action(
            life, {"action": "pickupitem_npc", "item": item_uid}, 200, delay=lfe.get_item_access_time(life, item_uid)
        )
예제 #5
0
파일: movement.py 프로젝트: flags/Reactor-3
def escape(life, targets):
	_avoid_positions = []
	_zones = [zones.get_zone_at_coords(life['pos'])]
	
	if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'escape'}]):
		if lfe.ticker(life, 'escape_refresh', 4):
			lfe.stop(life)
		else:
			return False
	
	for target_id in targets:
		_target = brain.knows_alife_by_id(life, target_id)
		_zone = zones.get_zone_at_coords(_target['last_seen_at'])
		
		if not _zone in _zones:
			_zones.append(_zone)
		
		_avoid_positions.append(_target['last_seen_at'])
	
	lfe.add_action(life, {'action': 'dijkstra_move',
	                      'rolldown': False,
	                      'zones': _zones,
	                      'goals': _avoid_positions,
	                      'reason': 'escape'},
	               100)
예제 #6
0
def find_target(life, target, distance=5, follow=False, call=True):
	_target = brain.knows_alife_by_id(life, target)
	_dist = numbers.distance(life['pos'], _target['last_seen_at'])
	
	_can_see = sight.can_see_target(life, target)
	if _can_see and _dist<=distance:
		if follow:
			return True
		
		lfe.stop(life)
		
		return True
	
	if _target['escaped'] == 1:
		search_for_target(life, target)
		return False
	
	if not _can_see and sight.can_see_position(life, _target['last_seen_at']) and _dist<distance:
		if call:
			if not _target['escaped']:
				memory.create_question(life, target, 'GET_LOCATION')
				
			speech.communicate(life, 'call', matches=[target])
		
		_target['escaped'] = 1
		
		return False
	
	if not lfe.path_dest(life) == tuple(_target['last_seen_at'][:2]):
		lfe.clear_actions(life)
		lfe.add_action(life,
			          {'action': 'move','to': _target['last_seen_at'][:2]},
			          200)
	
	return False
예제 #7
0
def explore_known_chunks(life):
    # Our first order of business is to figure out exactly what we're looking for.
    # There's a big difference between exploring the map looking for a purpose and
    # exploring the map with a purpose. Both will use similar routines but I wager
    # it'll actually be a lot harder to do it without there being some kind of goal
    # to at least start us in the right direction.

    # This function will kick in only if the ALife is idling, so looting is handled
    # automatically.

    # Note: Determining whether this fuction should run at all needs to be done inside
    # the module itself.
    _chunk_key = brain.retrieve_from_memory(life, "explore_chunk")
    _chunk = maps.get_chunk(_chunk_key)

    if life["path"] and chunks.position_is_in_chunk(lfe.path_dest(life), _chunk_key):
        return True

    if chunks.is_in_chunk(life, "%s,%s" % (_chunk["pos"][0], _chunk["pos"][1])):
        life["known_chunks"][_chunk_key]["last_visited"] = WORLD_INFO["ticks"]
        return False

    if not _chunk["ground"]:
        return False

    _pos_in_chunk = random.choice(_chunk["ground"])
    lfe.clear_actions(life)
    lfe.add_action(life, {"action": "move", "to": _pos_in_chunk}, 200)
    return True
예제 #8
0
def escape(life, targets):
    _avoid_positions = []
    _zones = [zones.get_zone_at_coords(life['pos'])]

    if lfe.find_action(life, [{
            'action': 'dijkstra_move',
            'reason': 'escape'
    }]):
        if lfe.ticker(life, 'escape_refresh', 4):
            lfe.stop(life)
        else:
            return False

    for target_id in targets:
        _target = brain.knows_alife_by_id(life, target_id)
        _zone = zones.get_zone_at_coords(_target['last_seen_at'])

        if not _zone in _zones:
            _zones.append(_zone)

        _avoid_positions.append(_target['last_seen_at'])

    lfe.add_action(
        life, {
            'action': 'dijkstra_move',
            'rolldown': False,
            'zones': _zones,
            'goals': _avoid_positions,
            'reason': 'escape'
        }, 100)
예제 #9
0
def collect_nearby_wanted_items(life,
                                only_visible=True,
                                matches={'type': 'gun'}):
    _highest = {'item': None, 'score': -100000}
    _nearby = sight.find_known_items(life,
                                     matches=matches,
                                     only_visible=only_visible)

    for item in _nearby:
        _item = brain.get_remembered_item(life, item)
        _score = _item['score']
        _score -= bad_numbers.distance(life['pos'], ITEMS[item]['pos'])

        if not _highest['item'] or _score > _highest['score']:
            _highest['score'] = _score
            _highest['item'] = ITEMS[item]

    if not _highest['item']:
        return True

    _empty_hand = lfe.get_open_hands(life)

    if not _empty_hand:
        print 'No open hands, managing....'
        for item_uid in lfe.get_held_items(life):
            _container = lfe.can_put_item_in_storage(life, item_uid)

            lfe.add_action(life, {
                'action': 'storeitem',
                'item': item_uid,
                'container': _container
            },
                           200,
                           delay=lfe.get_item_access_time(life, item_uid))
        return False

    if life['pos'] == _highest['item']['pos']:
        lfe.clear_actions(life)

        for action in lfe.find_action(life,
                                      matches=[{
                                          'action': 'pickupholditem'
                                      }]):
            #print 'I was picking up something else...',_highest['item']['name']
            return False

        lfe.add_action(life, {
            'action': 'pickupholditem',
            'item': _highest['item']['uid'],
            'hand': random.choice(_empty_hand)
        },
                       200,
                       delay=lfe.get_item_access_time(life,
                                                      _highest['item']['uid']))
        lfe.lock_item(life, _highest['item']['uid'])
    else:
        lfe.walk_to(life, _highest['item']['pos'])

    return False
예제 #10
0
파일: movement.py 프로젝트: flags/Reactor-3
def pick_up_item(life, item_uid):
	_not_moved = travel_to_position(life, ITEMS[item_uid]['pos'])
	
	if _not_moved:
		lfe.add_action(life,{'action': 'pickupitem_npc',
		                     'item': item_uid},
		                     200,
		                     delay=lfe.get_item_access_time(life, item_uid))
예제 #11
0
def perform_recipe(life, item, recipe):
    lfe.add_action(life, {
        'action': 'craft',
        'item_uid': item['uid'],
        'recipe_id': item['craft'].index(recipe)
    },
                   99999,
                   delay=recipe['time'])
예제 #12
0
파일: survival.py 프로젝트: flags/Reactor-3
def manage_inventory(life):
	if manage_hands(life):
		return False
	
	for weapon_uid in combat.get_equipped_weapons(life):
		if not combat.weapon_is_working(life, weapon_uid):
			if combat.weapon_is_in_preferred_working_condition(life, weapon_uid):
				if not len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
					combat.reload_weapon(life, weapon_uid)
				
					return True
	
	_item_to_wear = {'score': 0, 'item_uid': None}
	_item_to_equip = {'score': 0, 'item_uid': None}
		
	for item in [lfe.get_inventory_item(life, item) for item in lfe.get_all_unequipped_items(life)]:
		judgement.judge_item(life, item['uid'])
		_known_item = brain.get_remembered_item(life, item['uid'])
		
		if _known_item['score']:
			if lfe.can_wear_item(life, item['uid']):
				if _known_item['score'] > _item_to_wear['score']:
					_item_to_wear['score'] = _known_item['score']
					_item_to_wear['item_uid'] = item['uid']
			else:
				if rawparse.raw_has_section(life, 'items') and rawparse.raw_section_has_identifier(life, 'items', item['type']):
					_action = lfe.execute_raw(life, 'items', item['type'])
					
					if item['type'] == 'gun' and lfe.get_all_equipped_items(life, matches=[{'type': 'gun'}]):
						continue
					
					if _action == 'equip':
						if _known_item['score'] > _item_to_equip['score']:
							_item_to_equip['score'] = _known_item['score']
							_item_to_equip['item_uid'] = item['uid']
	
	_item = None
	if _item_to_wear['score'] > _item_to_equip['score']:
		_item = _item_to_wear['item_uid']
	elif _item_to_equip['item_uid']:
		_item = _item_to_equip['item_uid']
	
	if _item:
		_equip_action = {'action': 'equipitem', 'item': _item}
		
		if len(lfe.find_action(life, matches=[_equip_action])):
			return False
		
		lfe.add_action(life,
			_equip_action,
			401,
			delay=lfe.get_item_access_time(life, _item))
		
		return False
	
	return True
예제 #13
0
def pick_up_item(life, item_uid):
    _not_moved = travel_to_position(life, ITEMS[item_uid]['pos'])

    if _not_moved:
        lfe.add_action(life, {
            'action': 'pickupitem_npc',
            'item': item_uid
        },
                       200,
                       delay=lfe.get_item_access_time(life, item_uid))
예제 #14
0
파일: camps.py 프로젝트: flags/Reactor-3
def guard_camp(life):
	_delay = random.randint(25, jobs.get_job_detail(life['job'], 'pause'))
	
	if not life['path'] and not lfe.find_action(life, matches=[{'action': 'move'}]):
		_chunk = WORLD_INFO['chunk_map'][references.find_least_populated_key_in_reference(life, CAMPS[life['camp']]['reference'])]
		lfe.add_action(life,{'action': 'move',
			'to': random.choice(_chunk['ground'])},
			200,
			delay=_delay)
	
	return False
예제 #15
0
파일: combat.py 프로젝트: penny64/Reactor-3
def load_feed(life, weapon_uid, feed_uid):
	_load_action = {'action': 'reload',
	                'weapon': ITEMS[weapon_uid],
	                'ammo': ITEMS[feed_uid]}
	
	if lfe.find_action(life, matches=[_load_action]):
		return False
	
	lfe.add_action(life, _load_action, 200, delay=0)
	
	return True
예제 #16
0
파일: combat.py 프로젝트: flags/Reactor-3
def load_feed(life, weapon_uid, feed_uid):
	_load_action = {'action': 'reload',
	                'weapon': ITEMS[weapon_uid],
	                'ammo': ITEMS[feed_uid]}
	
	if lfe.find_action(life, matches=[_load_action]):
		return False
	
	lfe.add_action(life, _load_action, 200, delay=0)
	
	return True
예제 #17
0
def manage_inventory(life):
    if manage_hands(life):
        return False

    for weapon_uid in combat.get_equipped_weapons(life):
        if not combat.weapon_is_working(life, weapon_uid):
            if combat.weapon_is_in_preferred_working_condition(life, weapon_uid):
                combat.reload_weapon(life, weapon_uid)
                return True

    _item_to_wear = {"score": 0, "item_uid": None}
    _item_to_equip = {"score": 0, "item_uid": None}

    for item in [lfe.get_inventory_item(life, item) for item in lfe.get_all_unequipped_items(life)]:
        judgement.judge_item(life, item["uid"])
        _known_item = brain.get_remembered_item(life, item["uid"])

        if _known_item["score"]:
            if lfe.can_wear_item(life, item["uid"]):
                if _known_item["score"] > _item_to_wear["score"]:
                    _item_to_wear["score"] = _known_item["score"]
                    _item_to_wear["item_uid"] = item["uid"]
            else:
                if rawparse.raw_has_section(life, "items") and rawparse.raw_section_has_identifier(
                    life, "items", item["type"]
                ):
                    _action = lfe.execute_raw(life, "items", item["type"])

                    if _action == "equip":
                        if _known_item["score"] > _item_to_equip["score"]:
                            _item_to_equip["score"] = _known_item["score"]
                            _item_to_equip["item_uid"] = item["uid"]

    _item = None
    if _item_to_wear["score"] > _item_to_equip["score"]:
        _item = _item_to_wear["item_uid"]
    elif _item_to_equip["item_uid"]:
        _item = _item_to_equip["item_uid"]

    if _item:
        _equip_action = {"action": "equipitem", "item": _item}

        if len(lfe.find_action(life, matches=[_equip_action])):
            return False

        lfe.add_action(life, _equip_action, 401, delay=lfe.get_item_access_time(life, _item))

        return True

    return False
예제 #18
0
def collect_nearby_wanted_items(life, only_visible=True, matches={"type": "gun"}):
    _highest = {"item": None, "score": -100000}
    _nearby = sight.find_known_items(life, matches=matches, only_visible=only_visible)

    for item in _nearby:
        _item = brain.get_remembered_item(life, item)
        _score = _item["score"]
        _score -= numbers.distance(life["pos"], ITEMS[item]["pos"])

        if not _highest["item"] or _score > _highest["score"]:
            _highest["score"] = _score
            _highest["item"] = ITEMS[item]

    if not _highest["item"]:
        return True

    _empty_hand = lfe.get_open_hands(life)

    if not _empty_hand:
        print "No open hands, managing...."
        for item_uid in lfe.get_held_items(life):
            _container = lfe.can_put_item_in_storage(life, item_uid)

            lfe.add_action(
                life,
                {"action": "storeitem", "item": item_uid, "container": _container},
                200,
                delay=lfe.get_item_access_time(life, item_uid),
            )
        return False

    if life["pos"] == _highest["item"]["pos"]:
        lfe.clear_actions(life)

        for action in lfe.find_action(life, matches=[{"action": "pickupholditem"}]):
            # print 'I was picking up something else...',_highest['item']['name']
            return False

        lfe.add_action(
            life,
            {"action": "pickupholditem", "item": _highest["item"]["uid"], "hand": random.choice(_empty_hand)},
            200,
            delay=lfe.get_item_access_time(life, _highest["item"]["uid"]),
        )
        lfe.lock_item(life, _highest["item"]["uid"])
    else:
        lfe.walk_to(life, _highest["item"]["pos"])

    return False
예제 #19
0
def position_to_attack(life, target):
	if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'positioning for attack'}]):
		if not lfe.ticker(life, 'attack_position', 4):
			return False
	
	_target_positions, _zones = combat.get_target_positions_and_zones(life, [target])
	_nearest_target_score = zones.dijkstra_map(life['pos'], _target_positions, _zones, return_score=True)
	
	#TODO: Short or long-range weapon?
	#if _nearest_target_score >= sight.get_vision(life)/2:
	if not sight.can_see_position(life, brain.knows_alife_by_id(life, target)['last_seen_at'], block_check=True, strict=True) or sight.view_blocked_by_life(life, _target_positions[0], allow=[target]):
		print life['name'], 'changing position for combat...', life['name'], LIFE[target]['name']
		
		_avoid_positions = []
		for life_id in life['seen']:
			if life_id == target or life['id'] == life_id:
				continue
			
			if alife.judgement.can_trust(life, life_id):
				_avoid_positions.append(lfe.path_dest(LIFE[life_id]))
			else:
				_avoid_positions.append(brain.knows_alife_by_id(life, life_id)['last_seen_at'])
		
		_cover = _target_positions
		
		_zones = []
		for pos in _cover:
			_zone = zones.get_zone_at_coords(pos)
			
			if not _zone in _zones:
				_zones.append(_zone)
		
		if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': _cover[:], 'avoid_positions': _avoid_positions}]):
			lfe.stop(life)
			lfe.add_action(life, {'action': 'dijkstra_move',
				                  'rolldown': True,
				                  'goals': _cover[:],
			                      'orig_goals': _cover[:],
			                      'avoid_positions': _avoid_positions,
			                      'reason': 'positioning for attack'},
				           999)
			
			return False
		else:
			return False
	elif life['path']:
		lfe.stop(life)
	
	return True
예제 #20
0
def manage_hands(life):
    for item in [
            lfe.get_inventory_item(life, item)
            for item in lfe.get_held_items(life)
    ]:
        judgement.judge_item(life, item['uid'])
        _known_item = brain.get_remembered_item(life, item['uid'])

        for weapon in combat.get_equipped_weapons(life):
            if item['type'] == ITEMS[weapon]['feed'] and len(
                    item['rounds']) >= 5:
                combat.load_feed(life, weapon, item['uid'])

                return True

        if _known_item[
                'score']:  #judgement.get_score_of_highest_scoring_item(life):
            continue

        _equip_action = {'action': 'equipitem', 'item': item['uid']}

        if len(lfe.find_action(life, matches=[_equip_action])):
            return True

        if lfe.can_wear_item(life, item['uid']):
            lfe.add_action(life,
                           _equip_action,
                           401,
                           delay=lfe.get_item_access_time(life, item['uid']))
            return True

        _storage = lfe.can_put_item_in_storage(life, item['uid'])
        if not 'CAN_WEAR' in item['flags'] and _storage:
            _store_action = {
                'action': 'storeitem',
                'item': item['uid'],
                'container': _storage
            }

            if len(lfe.find_action(life, matches=[_store_action])):
                continue

            lfe.add_action(life,
                           _store_action,
                           401,
                           delay=lfe.get_item_access_time(life, item['uid']))
            return True

    return False
예제 #21
0
def travel_to_position(life, pos, stop_on_sight=False):
	if stop_on_sight and sight.can_see_position(life, pos):
		return True
	
	if not numbers.distance(life['pos'], pos):
		return True
	
	_dest = lfe.path_dest(life)
	if _dest and tuple(_dest[:2]) == tuple(pos[:2]):
		return False
	
	lfe.clear_actions(life)
	lfe.add_action(life,{'action': 'move','to': (pos[0],pos[1])},200)
	
	return False
예제 #22
0
파일: movement.py 프로젝트: flags/Reactor-3
def collect_nearby_wanted_items(life, only_visible=True, matches={'type': 'gun'}):
	_highest = {'item': None,'score': -100000}
	_nearby = sight.find_known_items(life, matches=matches, only_visible=only_visible)
	
	for item in _nearby:
		_item = brain.get_remembered_item(life, item)
		_score = _item['score']
		_score -= bad_numbers.distance(life['pos'], ITEMS[item]['pos'])
		
		if not _highest['item'] or _score > _highest['score']:
			_highest['score'] = _score
			_highest['item'] = ITEMS[item]
	
	if not _highest['item']:
		return True
	
	_empty_hand = lfe.get_open_hands(life)
	
	if not _empty_hand:
		print 'No open hands, managing....'
		for item_uid in lfe.get_held_items(life):
			_container = lfe.can_put_item_in_storage(life, item_uid)
			
			lfe.add_action(life, {'action': 'storeitem',
				'item': item_uid,
			     'container': _container},
				200,
				delay=lfe.get_item_access_time(life, item_uid))
		return False
	
	if life['pos'] == _highest['item']['pos']:
		lfe.clear_actions(life)
		
		for action in lfe.find_action(life, matches=[{'action': 'pickupholditem'}]):
			#print 'I was picking up something else...',_highest['item']['name']
			return False
		
		lfe.add_action(life,{'action': 'pickupholditem',
			'item': _highest['item']['uid'],
			'hand': random.choice(_empty_hand)},
			200,
			delay=lfe.get_item_access_time(life, _highest['item']['uid']))
		lfe.lock_item(life, _highest['item']['uid'])
	else:
		lfe.walk_to(life, _highest['item']['pos'])
	
	return False
예제 #23
0
def _refill_feed(life, feed):
	if not lfe.is_holding(life, feed['uid']) and not lfe.can_hold_item(life):
		logging.warning('No hands free to load ammo!')
		
		return False

	if not lfe.get_held_items(life, matches=[{'id': feed['uid']}]) and lfe.item_is_stored(life, feed['uid']) and not lfe.find_action(life, matches=[{'action': 'removeandholditem'}]):
		lfe.add_action(life,{'action': 'removeandholditem',
			'item': feed['uid']},
			200,
			delay=0)
		
		return False

	#TODO: No check for ammo type.
	
	_loading_rounds = len(lfe.find_action(life,matches=[{'action': 'refillammo'}]))
	if _loading_rounds >= len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])):
		#TODO: What?
		if not _loading_rounds:
			return True
		
		return False
	
	if len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
		return False
	
	_rounds = len(feed['rounds'])
	
	if _rounds>=feed['maxrounds']:
		print 'Full?'
		return True
	
	_ammo_count = len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
	_ammo_count += len(feed['rounds'])
	_rounds_to_load = numbers.clip(_ammo_count,0,feed['maxrounds'])
	for ammo in lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])[:_rounds_to_load]:		
		lfe.add_action(life,{'action': 'refillammo',
			'ammo': feed,
			'round': ammo},
			200,
			delay=3)
		
		_rounds += 1
	
	return False
예제 #24
0
def guard_camp(life):
    _delay = random.randint(25, jobs.get_job_detail(life['job'], 'pause'))

    if not life['path'] and not lfe.find_action(life,
                                                matches=[{
                                                    'action': 'move'
                                                }]):
        _chunk = WORLD_INFO['chunk_map'][
            references.find_least_populated_key_in_reference(
                life, CAMPS[life['camp']]['reference'])]
        lfe.add_action(life, {
            'action': 'move',
            'to': random.choice(_chunk['ground'])
        },
                       200,
                       delay=_delay)

    return False
예제 #25
0
파일: combat.py 프로젝트: penny64/Reactor-3
def _refill_feed(life, feed):
	if not lfe.is_holding(life, feed['uid']) and not lfe.can_hold_item(life):
		logging.warning('No hands free to load ammo!')
		
		return False

	if not lfe.get_held_items(life, matches=[{'id': feed['uid']}]) and lfe.item_is_stored(life, feed['uid']) and not lfe.find_action(life, matches=[{'action': 'removeandholditem'}]):
		lfe.add_action(life,{'action': 'removeandholditem',
			'item': feed['uid']},
			200,
			delay=0)
		
		return False

	#TODO: No check for ammo type.
	
	_loading_rounds = len(lfe.find_action(life, matches=[{'action': 'refillammo'}]))
	_bullets_in_inventory = len(lfe.get_all_inventory_items(life, matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
	
	if _loading_rounds:# >= _bullets_in_inventory:
		return False
	
	if len(lfe.find_action(life,matches=[{'action': 'refillammo'}])):
		return False
	
	_rounds = len(feed['rounds'])
	
	if _rounds>=feed['maxrounds'] or (not _bullets_in_inventory and _rounds):
		print 'Full?'
		return True
	
	_ammo_count = len(lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}]))
	_ammo_count += len(feed['rounds'])
	_rounds_to_load = numbers.clip(_ammo_count,0,feed['maxrounds'])
	for ammo in lfe.get_all_inventory_items(life,matches=[{'type': 'bullet', 'ammotype': feed['ammotype']}])[:_rounds_to_load]:		
		lfe.add_action(life,{'action': 'refillammo',
			'ammo': feed,
			'round': ammo},
			200,
			delay=3)
		
		_rounds += 1
	
	return False
예제 #26
0
def _equip_weapon(life, weapon_uid, feed_uid):
	_weapon = ITEMS[weapon_uid]
	_feed = ITEMS[feed_uid]
	
	#TODO: Need to refill ammo?
	if not weapons.get_feed(_weapon):
		#TODO: How much time should we spend loading rounds if we're in danger?
		if _refill_feed(life, _feed):
			load_feed(life, _weapon['uid'], _feed['uid'])
	else:
		print 'should be equippan?'
		lfe.add_action(life,{'action': 'equipitem',
			'item': weapon_uid},
			300,
			delay=0)
		
		print 'Loaded!'
		return True
	
	return True
예제 #27
0
파일: survival.py 프로젝트: flags/Reactor-3
def manage_hands(life):
	for item in [lfe.get_inventory_item(life, item) for item in lfe.get_held_items(life)]:
		judgement.judge_item(life, item['uid'])
		_known_item = brain.get_remembered_item(life, item['uid'])
		
		for weapon in combat.get_equipped_weapons(life):
			if item['type'] == ITEMS[weapon]['feed'] and len(item['rounds'])>=5:
				combat.load_feed(life, weapon, item['uid'])
				
				return True
		
		if _known_item['score']:#judgement.get_score_of_highest_scoring_item(life):
			continue
		
		_equip_action = {'action': 'equipitem',
				'item': item['uid']}
		
		if len(lfe.find_action(life, matches=[_equip_action])):
			return True
		
		if lfe.can_wear_item(life, item['uid']):
			lfe.add_action(life, _equip_action,
				401,
				delay=lfe.get_item_access_time(life, item['uid']))
			return True
		
		_storage = lfe.can_put_item_in_storage(life, item['uid'])
		if not 'CAN_WEAR' in item['flags'] and _storage:
			_store_action = {'action': 'storeitem',
				'item': item['uid'],
				'container': _storage}
			
			if len(lfe.find_action(life, matches=[_store_action])):
				continue
			
			lfe.add_action(life,_store_action,
				401,
				delay=lfe.get_item_access_time(life, item['uid']))
			return True
	
	return False
예제 #28
0
파일: combat.py 프로젝트: penny64/Reactor-3
def _equip_weapon(life, weapon_uid, feed_uid):
	_weapon = ITEMS[weapon_uid]
	_feed = ITEMS[feed_uid]
	
	#TODO: Need to refill ammo?
	if not weapons.get_feed(_weapon):
		#TODO: How much time should we spend loading rounds if we're in danger?
		
		if _refill_feed(life, _feed):
			load_feed(life, _weapon['uid'], _feed['uid'])
	else:
		print 'should be equippan?'
		lfe.add_action(life,{'action': 'equipitem',
			'item': weapon_uid},
			300,
			delay=0)
		
		print 'Loaded!'
		return True
	
	return True
예제 #29
0
def ranged_combat(life, targets):
	_target = get_closest_target(life, targets)
	
	if not _target:
		for target_id in targets:
			if brain.knows_alife_by_id(life, target_id)['escaped']:
				continue
			
			brain.knows_alife_by_id(life, target_id)['escaped'] = 1
		
		logging.error('No target for ranged combat.')
		return False
	
	if not life['path'] or not numbers.distance(lfe.path_dest(life), _target['last_seen_at']) == 0:
		movement.position_to_attack(life, _target['life']['id'])
	
	if sight.can_see_position(life, _target['last_seen_at'], block_check=True, strict=True) and not sight.view_blocked_by_life(life, _target['last_seen_at'], allow=[_target['life']['id']]):
		if sight.can_see_position(life, _target['life']['pos']):
			if not len(lfe.find_action(life, matches=[{'action': 'shoot'}])):
				for i in range(weapons.get_rounds_to_fire(weapons.get_weapon_to_fire(life))):
					lfe.add_action(life,{'action': 'shoot',
						'target': _target['last_seen_at'],
						'target_id': _target['life']['id'],
						'limb': 'chest'},
						5000,
						delay=int(round(life['recoil']-stats.get_recoil_recovery_rate(life))))
		else:
			lfe.memory(life,'lost sight of %s' % (' '.join(_target['life']['name'])), target=_target['life']['id'])
			
			_target['escaped'] = 1
			
			for send_to in judgement.get_trusted(life):
				speech.communicate(life,
			        'target_missing',
			        target=_target['life']['id'],
			        matches=[send_to])
	else:
		print life['name'], 'waiting...'
		return False
예제 #30
0
def explore_unknown_chunks(life):
    if life["path"]:
        return True

    _chunk_key = references.path_along_reference(life, "roads")

    if not _chunk_key:
        _best_reference = references._find_best_unknown_reference(life, "roads")["reference"]
        if not _best_reference:
            return False

        _chunk_key = references.find_nearest_key_in_reference(life, _best_reference, unknown=True, threshold=15)

    if not _chunk_key:
        return False

    _walkable_area = chunks.get_walkable_areas(_chunk_key)
    if not _walkable_area:
        print "no walkable area"
        return False

    _closest_pos = {"pos": None, "distance": -1}
    for pos in _walkable_area:
        _distance = numbers.distance(life["pos"], pos)

        if _distance <= 1:
            _closest_pos["pos"] = pos
            break

        if not _closest_pos["pos"] or _distance < _closest_pos["distance"]:
            _closest_pos["pos"] = pos
            _closest_pos["distance"] = _distance

    lfe.clear_actions(life)
    lfe.add_action(life, {"action": "move", "to": _closest_pos["pos"]}, 200)

    return True
예제 #31
0
def escape(life, targets):
    _avoid_positions = []
    _zones = [zones.get_zone_at_coords(life["pos"])]

    if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "escape"}]):
        if lfe.ticker(life, "escape_refresh", 4):
            lfe.stop(life)
        else:
            return False

    for target_id in targets:
        _target = brain.knows_alife_by_id(life, target_id)
        _zone = zones.get_zone_at_coords(_target["last_seen_at"])

        if not _zone in _zones:
            _zones.append(_zone)

        _avoid_positions.append(_target["last_seen_at"])

    lfe.add_action(
        life,
        {"action": "dijkstra_move", "rolldown": False, "zones": _zones, "goals": _avoid_positions, "reason": "escape"},
        100,
    )
예제 #32
0
def hide(life, targets):
    _target_positions = []
    _avoid_positions = []
    _zones = [zones.get_zone_at_coords(life["pos"])]

    if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "escaping"}]):
        if not lfe.ticker(life, "escaping", 6):
            return False

            # What can the targets see?
    for target_id in targets:
        _target = brain.knows_alife_by_id(life, target_id)
        _zone = zones.get_zone_at_coords(_target["last_seen_at"])

        if not _zone in _zones:
            _zones.append(_zone)

        fov.fov(
            _target["last_seen_at"],
            sight.get_vision(_target["life"]),
            callback=lambda pos: _avoid_positions.append(pos),
        )

        # What can we see?
    _can_see_positions = []
    fov.fov(life["pos"], sight.get_vision(life), callback=lambda pos: _can_see_positions.append(pos))

    # If there are no visible targets, we could be running away from a position we were attacked from
    _cover_exposed_at = brain.get_flag(life, "cover_exposed_at")

    if _cover_exposed_at:
        _avoid_exposed_cover_positions = set()

        for pos in _cover_exposed_at[:]:
            if tuple(pos[:2]) in _can_see_positions:
                _cover_exposed_at.remove(pos)

                continue

            fov.fov(
                pos,
                int(round(sight.get_vision(life) * 0.25)),
                callback=lambda pos: _avoid_exposed_cover_positions.add(pos),
            )

        for pos in _avoid_exposed_cover_positions:
            if not pos in _avoid_positions:
                _avoid_positions.append(pos)
    else:
        print "Something went wrong"

        return False

        # Overlay the two, finding positions we can see but the target can't
    for pos in _can_see_positions[:]:
        if pos in _avoid_positions:
            _can_see_positions.remove(pos)
            continue

            # Get rid of positions that are too close
        for target_id in targets:
            _target = brain.knows_alife_by_id(life, target_id)

            if numbers.distance(_target["last_seen_at"], pos) < 4:
                _can_see_positions.remove(pos)
                break

                # Now scan for cover to prevent hiding in the open
    for pos in _can_see_positions[:]:
        if chunks.get_chunk(chunks.get_chunk_key_at(pos))["max_z"] == 2:
            _can_see_positions.remove(pos)

    if not _can_see_positions:
        if life["pos"] in _cover_exposed_at:
            _cover_exposed_at.remove(life["pos"])

        return False

    if lfe.find_action(life, [{"action": "dijkstra_move", "goals": _can_see_positions[:]}]):
        return True

    lfe.stop(life)
    lfe.add_action(
        life,
        {
            "action": "dijkstra_move",
            "rolldown": True,
            "zones": _zones,
            "goals": _can_see_positions[:],
            "reason": "escaping",
        },
        200,
    )
예제 #33
0
def perform_recipe(life, item, recipe):
	lfe.add_action(life, {'action': 'craft',
	                      'item_uid': item['uid'],
	                      'recipe_id': item['craft'].index(recipe)},
	               99999,
	               delay=recipe['time'])
예제 #34
0
파일: combat.py 프로젝트: flags/Reactor-3
def ranged_combat(life, targets):
	_target = brain.knows_alife_by_id(life, get_closest_target(life, targets))
	
	#if not _target:
	#	for target_id in targets:
	#		if brain.knows_alife_by_id(life, target_id)['escaped']:
	#			continue
	#		
	#		brain.knows_alife_by_id(life, target_id)['escaped'] = 1
	#	
	#	logging.error('No target for ranged combat.')
	#	
	#	return False
	
	_engage_distance = get_engage_distance(life)
	_path_dest = lfe.path_dest(life)
	
	if not _path_dest:
		_path_dest = life['pos'][:]
	
	_target_distance = bad_numbers.distance(life['pos'], _target['last_seen_at'])
	
	#Get us near the target
	#if _target['last_seen_at']:
	movement.position_to_attack(life, _target['life']['id'], _engage_distance)
		
	if sight.can_see_position(life, _target['last_seen_at']):
		if _target_distance	<= _engage_distance:
			if sight.can_see_position(life, _target['life']['pos']):
				if not sight.view_blocked_by_life(life, _target['life']['pos'], allow=[_target['life']['id']]):
					lfe.clear_actions(life)
					
					if not len(lfe.find_action(life, matches=[{'action': 'shoot'}])) and _target['time_visible']>2:
						for i in range(weapons.get_rounds_to_fire(weapons.get_weapon_to_fire(life))):
							lfe.add_action(life, {'action': 'shoot',
							                      'target': _target['last_seen_at'],
							                      'target_id': _target['life']['id'],
							                      'limb': 'chest'},
							               300,
							               delay=int(round(life['recoil']-stats.get_recoil_recovery_rate(life))))
				else:
					_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
					_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
					_friendly_positions.append(life['pos'][:])
					
					if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
						lfe.add_action(life, {'action': 'dijkstra_move',
						                      'rolldown': True,
						                      'zones': _friendly_zones,
						                      'goals': [_target['life']['pos'][:]],
						                      'orig_goals': [_target['life']['pos'][:]],
						                      'avoid_positions': _friendly_positions,
						                      'reason': 'combat_position'},
						               100)
			else:
				lfe.memory(life,'lost sight of %s' % (' '.join(_target['life']['name'])), target=_target['life']['id'])
				
				_target['escaped'] = 1
				
				for send_to in judgement.get_trusted(life):
					speech.communicate(life,
					                   'target_missing',
					                   target=_target['life']['id'],
					                   matches=[send_to])
		#else:
			#print life['name']
			#_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
			#_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
			#_friendly_positions.append(life['pos'][:])
			
			#if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
			#	lfe.add_action(life, {'action': 'dijkstra_move',
			#		                'rolldown': True,
			#		                'zones': _friendly_zones,
			#		                'goals': [_target['life']['pos'][:]],
			#		                'orig_goals': [_target['life']['pos'][:]],
			#		                'avoid_positions': _friendly_positions,
			#		                'reason': 'combat_position'},
			#		         100)
			#	
			#	print '2'
		
	else:
		return False
예제 #35
0
def ranged_combat(life, targets):
    _target = brain.knows_alife_by_id(life, get_closest_target(life, targets))

    #if not _target:
    #	for target_id in targets:
    #		if brain.knows_alife_by_id(life, target_id)['escaped']:
    #			continue
    #
    #		brain.knows_alife_by_id(life, target_id)['escaped'] = 1
    #
    #	logging.error('No target for ranged combat.')
    #
    #	return False

    _engage_distance = get_engage_distance(life)
    _path_dest = lfe.path_dest(life)

    if not _path_dest:
        _path_dest = life['pos'][:]

    _target_distance = bad_numbers.distance(life['pos'],
                                            _target['last_seen_at'])

    #Get us near the target
    #if _target['last_seen_at']:
    movement.position_to_attack(life, _target['life']['id'], _engage_distance)

    if sight.can_see_position(life, _target['last_seen_at']):
        if _target_distance <= _engage_distance:
            if sight.can_see_position(life, _target['life']['pos']):
                if not sight.view_blocked_by_life(
                        life,
                        _target['life']['pos'],
                        allow=[_target['life']['id']]):
                    lfe.clear_actions(life)

                    if not len(
                            lfe.find_action(
                                life, matches=[{
                                    'action': 'shoot'
                                }])) and _target['time_visible'] > 2:
                        for i in range(
                                weapons.get_rounds_to_fire(
                                    weapons.get_weapon_to_fire(life))):
                            lfe.add_action(
                                life, {
                                    'action': 'shoot',
                                    'target': _target['last_seen_at'],
                                    'target_id': _target['life']['id'],
                                    'limb': 'chest'
                                },
                                300,
                                delay=int(
                                    round(
                                        life['recoil'] -
                                        stats.get_recoil_recovery_rate(life))))
                else:
                    _friendly_positions, _friendly_zones = get_target_positions_and_zones(
                        life, judgement.get_trusted(life))
                    _friendly_zones.append(
                        zones.get_zone_at_coords(life['pos']))
                    _friendly_positions.append(life['pos'][:])

                    if not lfe.find_action(
                            life, [{
                                'action': 'dijkstra_move',
                                'orig_goals': [_target['life']['pos'][:]],
                                'avoid_positions': _friendly_positions
                            }]):
                        lfe.add_action(
                            life, {
                                'action': 'dijkstra_move',
                                'rolldown': True,
                                'zones': _friendly_zones,
                                'goals': [_target['life']['pos'][:]],
                                'orig_goals': [_target['life']['pos'][:]],
                                'avoid_positions': _friendly_positions,
                                'reason': 'combat_position'
                            }, 100)
            else:
                lfe.memory(life,
                           'lost sight of %s' %
                           (' '.join(_target['life']['name'])),
                           target=_target['life']['id'])

                _target['escaped'] = 1

                for send_to in judgement.get_trusted(life):
                    speech.communicate(life,
                                       'target_missing',
                                       target=_target['life']['id'],
                                       matches=[send_to])
        #else:
        #print life['name']
        #_friendly_positions, _friendly_zones = get_target_positions_and_zones(life, judgement.get_trusted(life))
        #_friendly_zones.append(zones.get_zone_at_coords(life['pos']))
        #_friendly_positions.append(life['pos'][:])

        #if not lfe.find_action(life, [{'action': 'dijkstra_move', 'orig_goals': [_target['life']['pos'][:]], 'avoid_positions': _friendly_positions}]):
        #	lfe.add_action(life, {'action': 'dijkstra_move',
        #		                'rolldown': True,
        #		                'zones': _friendly_zones,
        #		                'goals': [_target['life']['pos'][:]],
        #		                'orig_goals': [_target['life']['pos'][:]],
        #		                'avoid_positions': _friendly_positions,
        #		                'reason': 'combat_position'},
        #		         100)
        #
        #	print '2'

    else:
        return False
예제 #36
0
def hide(life, targets):
    _target_positions = []
    _avoid_positions = []
    _zones = [zones.get_zone_at_coords(life['pos'])]

    if lfe.find_action(life, [{
            'action': 'dijkstra_move',
            'reason': 'escaping'
    }]):
        if not lfe.ticker(life, 'escaping', 6):
            return False

    #What can the targets see?
    for target_id in targets:
        _target = brain.knows_alife_by_id(life, target_id)
        _zone = zones.get_zone_at_coords(_target['last_seen_at'])

        if not _zone in _zones:
            _zones.append(_zone)

        fov.fov(_target['last_seen_at'],
                sight.get_vision(_target['life']),
                callback=lambda pos: _avoid_positions.append(pos))

    #What can we see?
    _can_see_positions = []
    fov.fov(life['pos'],
            sight.get_vision(life),
            callback=lambda pos: _can_see_positions.append(pos))

    #If there are no visible targets, we could be running away from a position we were attacked from
    _cover_exposed_at = brain.get_flag(life, 'cover_exposed_at')

    if _cover_exposed_at:
        _avoid_exposed_cover_positions = set()

        for pos in _cover_exposed_at[:]:
            if tuple(pos[:2]) in _can_see_positions:
                _cover_exposed_at.remove(pos)

                continue

            fov.fov(
                pos,
                int(round(sight.get_vision(life) * .25)),
                callback=lambda pos: _avoid_exposed_cover_positions.add(pos))

        for pos in _avoid_exposed_cover_positions:
            if not pos in _avoid_positions:
                _avoid_positions.append(pos)
    else:
        print 'Something went wrong'

        return False

    #Overlay the two, finding positions we can see but the target can't
    for pos in _can_see_positions[:]:
        if pos in _avoid_positions:
            _can_see_positions.remove(pos)
            continue

        #Get rid of positions that are too close
        for target_id in targets:
            _target = brain.knows_alife_by_id(life, target_id)

            if bad_numbers.distance(_target['last_seen_at'], pos) < 4:
                _can_see_positions.remove(pos)
                break

    #Now scan for cover to prevent hiding in the open
    for pos in _can_see_positions[:]:
        if chunks.get_chunk(chunks.get_chunk_key_at(pos))['max_z'] == 2:
            _can_see_positions.remove(pos)

    if not _can_see_positions:
        if life['pos'] in _cover_exposed_at:
            _cover_exposed_at.remove(life['pos'])

        return False

    if lfe.find_action(life, [{
            'action': 'dijkstra_move',
            'goals': _can_see_positions[:]
    }]):
        return True

    lfe.stop(life)
    lfe.add_action(
        life, {
            'action': 'dijkstra_move',
            'rolldown': True,
            'zones': _zones,
            'goals': _can_see_positions[:],
            'reason': 'escaping'
        }, 200)
예제 #37
0
def position_to_attack(life, target, engage_distance):
    if lfe.find_action(life, [{
            'action': 'dijkstra_move',
            'reason': 'positioning for attack'
    }]):
        if not lfe.ticker(life, 'attack_position', 4):
            return False

    _target_positions, _zones = combat.get_target_positions_and_zones(
        life, [target])
    _can_see = alife.sight.can_see_position(life,
                                            _target_positions[0],
                                            get_path=True)
    _distance = bad_numbers.distance(life['pos'], _target_positions[0])

    if _can_see and len(_can_see) < engage_distance * .85:
        if life['path']:
            lfe.stop(life)
    elif _distance < engage_distance * .9:
        _avoid_positions = set()
        _target_area = set()

        for life_id in alife.judgement.get_trusted(life,
                                                   visible=False,
                                                   only_recent=True):
            fov.fov(LIFE[life_id]['pos'],
                    int(round(sight.get_vision(life) * .25)),
                    callback=lambda pos: _avoid_positions.add(pos))

        fov.fov(_target_positions[0],
                int(round(sight.get_vision(life) * .15)),
                callback=lambda pos: _target_area.add(pos))

        _min_view_distance = int(round(sight.get_vision(life) * .25))
        _max_view_distance = int(round(sight.get_vision(life) * .5))
        _attack_positions = set(
            zones.dijkstra_map(
                life['pos'],
                _target_positions,
                _zones,
                rolldown=True,
                return_score_in_range=[_min_view_distance,
                                       _max_view_distance]))

        _attack_positions = _attack_positions - _target_area

        if not _attack_positions:
            return False

        if not lfe.find_action(life, [{
                'action': 'dijkstra_move',
                'orig_goals': list(_attack_positions),
                'avoid_positions': list(_avoid_positions)
        }]):
            lfe.stop(life)

            lfe.add_action(
                life, {
                    'action':
                    'dijkstra_move',
                    'rolldown':
                    True,
                    'goals': [
                        list(p)
                        for p in random.sample(_attack_positions,
                                               len(_attack_positions) / 2)
                    ],
                    'orig_goals':
                    list(_attack_positions),
                    'avoid_positions':
                    list(_avoid_positions),
                    'reason':
                    'positioning for attack'
                }, 999)

            return False
    else:
        _can_see_positions = set()
        _target_area = set()
        _avoid_positions = set()

        fov.fov(life['pos'],
                int(round(sight.get_vision(life) * .75)),
                callback=lambda pos: _can_see_positions.add(pos))
        fov.fov(_target_positions[0],
                int(round(sight.get_vision(life) * .75)),
                callback=lambda pos: _target_area.add(pos))

        for life_id in alife.judgement.get_trusted(life,
                                                   visible=False,
                                                   only_recent=True):
            _path_dest = lfe.path_dest(LIFE[life_id])

            if not _path_dest:
                continue

            if len(_path_dest) == 2:
                _path_dest = list(_path_dest[:])
                _path_dest.append(LIFE[life_id]['pos'][2])

            fov.fov(_path_dest,
                    5,
                    callback=lambda pos: _avoid_positions.add(pos))

        _avoid_positions = list(_avoid_positions)
        _sneak_positions = _can_see_positions - _target_area
        _move_positions = zones.dijkstra_map(LIFE[target]['pos'],
                                             list(_sneak_positions),
                                             _zones,
                                             rolldown=True)

        if not _move_positions:
            travel_to_position(life, list(_target_positions[0]))
            return False

        if not lfe.find_action(life, [{
                'action': 'dijkstra_move',
                'orig_goals': _move_positions,
                'avoid_positions': _avoid_positions
        }]):
            lfe.stop(life)

            lfe.add_action(
                life, {
                    'action': 'dijkstra_move',
                    'rolldown': True,
                    'goals': [list(p) for p in _move_positions],
                    'orig_goals': _move_positions,
                    'avoid_positions': _avoid_positions,
                    'reason': 'positioning for attack'
                }, 999)

            return False

    return True
예제 #38
0
def manage_inventory(life):
    if manage_hands(life):
        return False

    for weapon_uid in combat.get_equipped_weapons(life):
        if not combat.weapon_is_working(life, weapon_uid):
            if combat.weapon_is_in_preferred_working_condition(
                    life, weapon_uid):
                if not len(
                        lfe.find_action(life,
                                        matches=[{
                                            'action': 'refillammo'
                                        }])):
                    combat.reload_weapon(life, weapon_uid)

                    return True

    _item_to_wear = {'score': 0, 'item_uid': None}
    _item_to_equip = {'score': 0, 'item_uid': None}

    for item in [
            lfe.get_inventory_item(life, item)
            for item in lfe.get_all_unequipped_items(life)
    ]:
        judgement.judge_item(life, item['uid'])
        _known_item = brain.get_remembered_item(life, item['uid'])

        if _known_item['score']:
            if lfe.can_wear_item(life, item['uid']):
                if _known_item['score'] > _item_to_wear['score']:
                    _item_to_wear['score'] = _known_item['score']
                    _item_to_wear['item_uid'] = item['uid']
            else:
                if rawparse.raw_has_section(
                        life, 'items') and rawparse.raw_section_has_identifier(
                            life, 'items', item['type']):
                    _action = lfe.execute_raw(life, 'items', item['type'])

                    if item['type'] == 'gun' and lfe.get_all_equipped_items(
                            life, matches=[{
                                'type': 'gun'
                            }]):
                        continue

                    if _action == 'equip':
                        if _known_item['score'] > _item_to_equip['score']:
                            _item_to_equip['score'] = _known_item['score']
                            _item_to_equip['item_uid'] = item['uid']

    _item = None
    if _item_to_wear['score'] > _item_to_equip['score']:
        _item = _item_to_wear['item_uid']
    elif _item_to_equip['item_uid']:
        _item = _item_to_equip['item_uid']

    if _item:
        _equip_action = {'action': 'equipitem', 'item': _item}

        if len(lfe.find_action(life, matches=[_equip_action])):
            return False

        lfe.add_action(life,
                       _equip_action,
                       401,
                       delay=lfe.get_item_access_time(life, _item))

        return False

    return True
예제 #39
0
def position_to_attack(life, target, engage_distance):
    if lfe.find_action(life, [{"action": "dijkstra_move", "reason": "positioning for attack"}]):
        if not lfe.ticker(life, "attack_position", 4):
            return False

    _target_positions, _zones = combat.get_target_positions_and_zones(life, [target])
    _can_see = alife.sight.can_see_position(life, _target_positions[0], get_path=True)
    _distance = numbers.distance(life["pos"], _target_positions[0])

    if _can_see and len(_can_see) < engage_distance * 0.85:
        if life["path"]:
            lfe.stop(life)
    elif _distance < engage_distance * 0.9:
        _avoid_positions = set()
        _target_area = set()

        for life_id in alife.judgement.get_trusted(life, visible=False, only_recent=True):
            fov.fov(
                LIFE[life_id]["pos"],
                int(round(sight.get_vision(life) * 0.25)),
                callback=lambda pos: _avoid_positions.add(pos),
            )

        fov.fov(
            _target_positions[0], int(round(sight.get_vision(life) * 0.15)), callback=lambda pos: _target_area.add(pos)
        )

        _min_view_distance = int(round(sight.get_vision(life) * 0.25))
        _max_view_distance = int(round(sight.get_vision(life) * 0.5))
        _attack_positions = set(
            zones.dijkstra_map(
                life["pos"],
                _target_positions,
                _zones,
                rolldown=True,
                return_score_in_range=[_min_view_distance, _max_view_distance],
            )
        )

        _attack_positions = _attack_positions - _target_area

        if not _attack_positions:
            return False

        if not lfe.find_action(
            life,
            [
                {
                    "action": "dijkstra_move",
                    "orig_goals": list(_attack_positions),
                    "avoid_positions": list(_avoid_positions),
                }
            ],
        ):
            lfe.stop(life)

            lfe.add_action(
                life,
                {
                    "action": "dijkstra_move",
                    "rolldown": True,
                    "goals": [list(p) for p in random.sample(_attack_positions, len(_attack_positions) / 2)],
                    "orig_goals": list(_attack_positions),
                    "avoid_positions": list(_avoid_positions),
                    "reason": "positioning for attack",
                },
                999,
            )

            return False
    else:
        _can_see_positions = set()
        _target_area = set()
        _avoid_positions = set()

        fov.fov(
            life["pos"], int(round(sight.get_vision(life) * 0.75)), callback=lambda pos: _can_see_positions.add(pos)
        )
        fov.fov(
            _target_positions[0], int(round(sight.get_vision(life) * 0.75)), callback=lambda pos: _target_area.add(pos)
        )

        for life_id in alife.judgement.get_trusted(life, visible=False, only_recent=True):
            _path_dest = lfe.path_dest(LIFE[life_id])

            if not _path_dest:
                continue

            if len(_path_dest) == 2:
                _path_dest = list(_path_dest[:])
                _path_dest.append(LIFE[life_id]["pos"][2])

            fov.fov(_path_dest, 5, callback=lambda pos: _avoid_positions.add(pos))

        _avoid_positions = list(_avoid_positions)
        _sneak_positions = _can_see_positions - _target_area
        _move_positions = zones.dijkstra_map(LIFE[target]["pos"], list(_sneak_positions), _zones, rolldown=True)

        if not _move_positions:
            travel_to_position(life, list(_target_positions[0]))
            return False

        if not lfe.find_action(
            life, [{"action": "dijkstra_move", "orig_goals": _move_positions, "avoid_positions": _avoid_positions}]
        ):
            lfe.stop(life)

            lfe.add_action(
                life,
                {
                    "action": "dijkstra_move",
                    "rolldown": True,
                    "goals": [list(p) for p in _move_positions],
                    "orig_goals": _move_positions,
                    "avoid_positions": _avoid_positions,
                    "reason": "positioning for attack",
                },
                999,
            )

            return False

    return True
예제 #40
0
def escape(life, targets):
	_target_positions = []
	_avoid_positions = []
	_zones = [zones.get_zone_at_coords(life['pos'])]
	
	if lfe.find_action(life, [{'action': 'dijkstra_move', 'reason': 'escaping'}]):
		if not lfe.ticker(life, 'escaping', 4):
			return False
	
	#What can the targets see?
	for target_id in targets:
		_target = brain.knows_alife_by_id(life, target_id)
		_zone = zones.get_zone_at_coords(_target['last_seen_at'])
		
		if not _zone in _zones:
			_zones.append(_zone)
		
		fov.fov(_target['last_seen_at'], sight.get_vision(_target['life']), callback=lambda pos: _avoid_positions.append(pos))
	
	#What can we see?
	_can_see_positions = []
	fov.fov(life['pos'], sight.get_vision(life), callback=lambda pos: _can_see_positions.append(pos))
	
	#If there are no visible targets, we could be running away from a position we were attacked from
	_cover_exposed_at = brain.get_flag(life, 'cover_exposed_at')
	
	if _cover_exposed_at:
		_avoid_exposed_cover_positions = set()
		
		for pos in _cover_exposed_at[:]:
			if tuple(pos[:2]) in _can_see_positions:
				print 'ok!!!'*20
				_cover_exposed_at.remove(pos)
				continue
			
			fov.fov(pos, int(round(sight.get_vision(life)*.25)), callback=lambda pos: _avoid_exposed_cover_positions.add(pos))
		
		for pos in _avoid_exposed_cover_positions:
			if not pos in _avoid_positions:
				_avoid_positions.append(pos)
	
	#Overlay the two, finding positions we can see but the target can't
	for pos in _can_see_positions[:]:
		if pos in _avoid_positions:
			_can_see_positions.remove(pos)
			continue
	
		#Get rid of positions that are too close
		for target_id in targets:
			_target = brain.knows_alife_by_id(life, target_id)
			
			#TODO: Unhardcode 15
			if numbers.distance(_target['last_seen_at'], pos)<10:
				_can_see_positions.remove(pos)
				break
	
	#Now scan for cover to prevent hiding in the open
	for pos in _can_see_positions[:]:
		if chunks.get_chunk(chunks.get_chunk_key_at(pos))['max_z'] == 2:
			_can_see_positions.remove(pos)
	
	#for target_id in targets:
		#_target = brain.knows_alife_by_id(life, target_id)
		#_target_positions.append(_target['last_seen_at'][:])
		#_zone = zones.get_zone_at_coords(_target['last_seen_at'])
		
		#if not _zone in _zones:
		#	_zones.append(_zone)
		
		#for chunk_key in chunks.get_visible_chunks_from(_target['last_seen_at'], sight.get_vision(_target['life'])):
		#	if chunk_key in _visible_target_chunks:
		#		continue
			
		#	_visible_target_chunks.append(chunk_key)
	
	#for friendly_id in life['seen']:
	#	_chunk_key = lfe.get_current_chunk_id(LIFE[friendly_id])
	#	
	#	if not _chunk_key in _visible_target_chunks:
	#		_visible_target_chunks.append(_chunk_key)
	
	#if not _target_positions:
	#	return False
	
	#TODO: #combat: For lower limit in return_score_in_range, use range of weapon
	#_cover = zones.dijkstra_map(life['pos'],
	#                            _avoid_positions,
	#                            _zones,
	#                            avoid_chunks=[],
	#                            return_score_in_range=[1, 5]) # sight.get_vision(life)
	#_cover = [(c[0], c[1], life['pos'][2]) for c in _cover]
	#if not _cover:
	#	return False
	
	#_zones = [zones.get_zone_at_coords(life['pos'])]
	#for _pos in _cover:
	#	_zone = zones.get_zone_at_coords(_pos)
		
	#	if not _zone in _zones:
	#		_zones.append(_zone)
	
	if not _can_see_positions:
		return False
	
	if lfe.find_action(life, [{'action': 'dijkstra_move', 'goals': _can_see_positions[:]}]):
		return True
	
	lfe.stop(life)
	lfe.add_action(life, {'action': 'dijkstra_move',
	                      'rolldown': True,
	                      'zones': _zones,
	                      'goals': _can_see_positions[:],
	                      'reason': 'escaping'},
	               999)