Beispiel #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
Beispiel #2
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
Beispiel #3
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
Beispiel #4
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
Beispiel #5
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.clear_actions(life)
		lfe.add_action(life,{'action': 'move','to': _highest['item']['pos'][:2]},200)
	
	return False
Beispiel #6
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