def ping(**kwargs): strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] logger = log.get_logger(__name__, strategy['bot']) last_ping = listener.game_state['ping'] if 'ping' in listener.game_state.keys() else 0 logger.info('Sending order to bot API: {}'.format('ping')) orders_queue.put(('ping',)) start = time.time() waiting = True while waiting: if 'ping' in listener.game_state.keys(): if last_ping != listener.game_state['ping']: waiting = False time.sleep(0.05) travel_time = time.time() - start logger.info('Received pong response in {}'.format(travel_time)) strategy['report'] = { 'success': True, 'details': 'Response time : {}'.format(travel_time) } # Properly closing the logger so there are not as many as calls to this function. log.close_logger(logger) return strategy
def goto(**kwargs): strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] target_x = strategy['parameters']['x'] target_y = strategy['parameters']['y'] target_cell = strategy['parameters']['cell'] if 'cell' in strategy[ 'parameters'] else None target_worldmap = strategy['parameters'][ 'worldmap'] if 'worldmap' in strategy['parameters'] and strategy[ 'parameters']['worldmap'] is not None else 1 logger = log.get_logger(__file__, strategy['bot']) path_maker = PathMaker( strategy=strategy, listener=listener, orders_queue=orders_queue, logger=logger, assets=assets, target_coord=(target_x, target_y), target_cell=target_cell, worldmap=target_worldmap, ) strategy['report'] = path_maker.make_path() log.close_logger(logger) return strategy
def on_close(self): if self.stop[0]: self.logger.info("Websocket at {} closed successfully".format(self.connection_string)) logger.close_logger(self.logger) else: self.logger.error("Websocket at {} closed unexpectedly".format(self.connection_string)) logger.close_logger(self.logger)
def get_game_state(**kwargs): """ A strategy to display a bot's game state. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start = time.time() game_state = listener.game_state execution_time = time.time() - start logger.info('Fetched game state in {}s'.format(execution_time)) pos = game_state['pos'] if 'pos' in game_state else [-100, -100] worldmap = game_state['worldmap'] if 'worldmap' in game_state else -100 cell = game_state['cell'] if 'cell' in game_state else -100 misc_stat = game_state['inventory'] if 'inventory' in game_state.keys( ) else None strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time, 'game_state': (pos, worldmap, cell, misc_stat) } } log.close_logger(logger) return strategy
def run(self): while 1: strategy = self.strategies_queue.get() if 'stop' in strategy.keys(): # Kill the commander # Stop the listener if not self.listener_crashed[0]: self.logger.info('Shutting down listener') self.listener.stop = True # Stop the connector if not self.connection_crashed[0]: self.logger.info('Shutting down connector') self.orders_queue.put( (json.dumps({'command': 'conn_shutdown'}), )) Thread(target=strategies.support_functions.update_profile, args=(self.bot['name'], 'connected', False)).start() logger.close_logger(self.logger) break else: # Business as usual self.logger.info( 'Received strategy from swarm node: {}'.format(strategy)) self.execute_strategy(strategy)
def run(self): self.logger.info('Starting listening for game state changes') while not self.stop: data = json.loads(self.output_queue.get()[0]) # self.logger.info('Listener received {}'.format(data)) self.messages_queue.append((time.time(), data)) self.messages_queue = self.messages_queue[1:] if len(self.messages_queue) > 100 else self.messages_queue self.update_game_state(data) self.game_state = json.loads(json.dumps(self._game_state)) self.logger.info('Listener shut down') logger.close_logger(self.logger)
def bank_close(**kwargs): """ A strategy to close a bank :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() if not listener.game_state['storage_open']: logger.info('Closed bank in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': {'Execution time': 0} } log.close_logger(logger) return strategy # Open NPC order = { 'command': 'close_npc', 'parameters': {} } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if not listener.game_state['storage_open']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning('Failed to close bank {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': {'Execution time': execution_time, 'Reason': 'Failed to close bank {}s'.format(execution_time)} } log.close_logger(logger) return strategy execution_time = time.time() - global_start logger.info('Closed bank in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': {'Execution time': execution_time} } log.close_logger(logger) return strategy
def disconnect(**kwargs): """ A strategy to disconnect a bot. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] logger = log.get_logger(__name__, strategy['bot']) if 'connected' in listener.game_state.keys(): if not listener.game_state['connected']: logger.info('Bot disconnected in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': {'Execution time': 0} } log.close_logger(logger) return strategy order = { 'command': 'disconnect', 'parameters': { 'name': strategy['bot'] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 20 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'connected' in listener.game_state.keys(): if not listener.game_state['connected']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed disconnecting in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': {'Execution time': execution_time, 'Reason': 'Timeout'} } log.close_logger(logger) return strategy logger.info('Disconnected {} in {}s'.format(strategy['bot'], execution_time)) strategy['report'] = { 'success': True, 'details': {'Execution time': execution_time} } log.close_logger(logger) return strategy
def auctionh_close(**kwargs): """ A strategy to close the auction house. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() if not listener.game_state['auction_house_info']: strategy['report'] = { 'success': True, 'details': {'Execution time': time.time() - global_start} } log.close_logger(logger) return strategy order = { "command": "close_npc" } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'auction_house_info' in listener.game_state.keys(): if not listener.game_state['auction_house_info']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed closing the auction house in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': {'Execution time': execution_time, 'Reason': 'Failed closing the auction house in {}s'.format(execution_time)} } log.close_logger(logger) return strategy logger.info('Closed the auction house in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': {'Execution time': time.time() - global_start} } log.close_logger(logger) return strategy
def bank_get_items(**kwargs): """ A strategy to get items from the bank :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() items_to_transfer = {} if 'parameters' in strategy.keys( ) and 'items' in strategy['parameters'].keys(): if strategy['parameters']['items'] != 'all' and strategy['parameters'][ 'items'] is not None: for item in strategy['parameters']['items']: items_to_transfer[item['general_id']] = item[ 'quantity'] if 'quantity' in item.keys() else 'all' else: items_to_transfer = 'all' else: items_to_transfer = 'all' if not listener.game_state['storage_open']: logger.warning('Bank is not open') strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Bank is not open' } } log.close_logger(logger) return strategy # Check that all requested items with a specified quantity are in the storage if type(items_to_transfer) is dict: for key in items_to_transfer.keys(): found = False for item in listener.game_state['storage_content']['objects']: if item['objectGID'] == key: found = True if not found: logger.warning( 'Object {}/{} with requested quantity {} is not in the storage' .format(key, assets['id_2_names'][str(key)], items_to_transfer[key])) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Object {}/{} with requested quantity {} is not in the storage' .format(key, assets['id_2_names'][str(key)], items_to_transfer[key]) } } log.close_logger(logger) return strategy uids_to_transfer_all = [] uids_to_transfer_specified = [] transfer_recap = [] for item in listener.game_state['storage_content']['objects']: if items_to_transfer == 'all': transfer_recap.append({ 'GID': item['objectGID'], 'name': assets['id_2_names'][str(item['objectGID'])], 'quantity': item['quantity'], 'weight_one': assets['id_2_weight'][str(item['objectGID'])] }) uids_to_transfer_all.append(item['objectUID']) elif item['objectGID'] in items_to_transfer.keys(): transfer_recap.append({ 'GID': item['objectGID'], 'quantity': item['quantity'], 'weight_one': assets['id_2_weight'][str(item['objectGID'])] }) if items_to_transfer[item['objectGID']] == 'all': uids_to_transfer_all.append(item['objectUID']) elif items_to_transfer[item['objectGID']] > 0: if item['quantity'] < items_to_transfer[item['objectGID']]: logger.warning( 'Requested quantity of {} {}:{} is not available in storage ({} available )' .format(items_to_transfer[item['objectGID']], item['objectGID'], assets['id_2_names'][str(item['objectGID'])], item['quantity'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Requested quantity of {} {}/{} is not available in storage ({} available )' .format( items_to_transfer[item['objectGID']], item['objectGID'], assets['id_2_names'][str(item['objectGID'])], item['quantity']) } } log.close_logger(logger) return strategy uids_to_transfer_specified.append({ 'unique_id': item['objectUID'], 'quantity': items_to_transfer[item['objectGID']] }) transfer_recap[-1]['quantity'] = items_to_transfer[ item['objectGID']] # Check weight available_weight = listener.game_state['max_weight'] - listener.game_state[ 'weight'] transfer_weight = sum( [item['quantity'] * item['weight_one'] for item in transfer_recap]) if transfer_weight > available_weight: logger.warning( 'Requested transfer ({} pods) would exceed carry capacity ({} pods)' .format(transfer_weight, available_weight)) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Requested transfer ({} pods) would exceed carry capacity ({} pods)' .format(transfer_weight, available_weight) } } log.close_logger(logger) return strategy # Transfer pack (quantity unspecified) if len(uids_to_transfer_all): inventory_before = json.loads( json.dumps(listener.game_state['inventory'])) order = { "command": "storage_to_inv_list", "parameters": { "items_uids": uids_to_transfer_all } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys( ) else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['inventory'] != inventory_before: waiting = False time.sleep(0.05) execution_time = time.time() - global_start if waiting: logger.warning( 'Failed to get pack of items {} from bank in {}s'.format( uids_to_transfer_all, execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to get pack of items {} from bank in {}s'.format( uids_to_transfer_all, execution_time) } } log.close_logger(logger) return strategy # Transfer specified for item in uids_to_transfer_specified: inventory_before = json.loads( json.dumps(listener.game_state['inventory'])) order = { "command": "storage_to_inv", "parameters": { "item_uid": item['unique_id'], "quantity": item['quantity'] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys( ) else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['inventory'] != inventory_before: waiting = False time.sleep(0.05) execution_time = time.time() - global_start if waiting: logger.warning('Failed to get {} item {} from bank in {}s'.format( item['quantity'], item['unique_id'], execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to get {} item {} from bank in {}s'.format( item['quantity'], item['unique_id'], execution_time) } } log.close_logger(logger) return strategy logger.info( 'Transferred from storage to inventory: {}'.format(transfer_recap)) strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start, 'Transfer': transfer_recap } } log.close_logger(logger) return strategy
def go_to_incarnam(**kwargs): """ A strategy to go from Astrub to Incarnam trough the portal :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() # Enter the portal room door_skill_id = 184 element_id, skill_uid = None, None for element in listener.game_state['map_elements']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys( ) and skill['skillId'] == door_skill_id: element_id = element['elementId'] skill_uid = skill['skillInstanceUid'] if element_id is None or skill_uid is None: logger.warn('Failed entering the portal room in {}s'.format(0)) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Could not find skill UID or element id' } } log.close_logger(logger) return strategy order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['map_id'] == 192416776: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn( 'Failed entering the portal room in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy logger.info('Entered the portal room in {}s'.format(execution_time)) # Go to cell 468 order = { 'command': 'move', 'parameters': { "isUsingNewMovementSystem": False, "cells": [[True, False, 0, 0, True, 0] for _ in range(560)], "target_cell": 468 } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if listener.game_state['cell'] == 468: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed going to cell 468 in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Use the portal door_skill_id = 184 element_id, skill_uid = None, None for element in listener.game_state['map_elements']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys( ) and skill['skillId'] == door_skill_id: element_id = element['elementId'] skill_uid = skill['skillInstanceUid'] if element_id is None or skill_uid is None: logger.warn('Failed entering the portal room in {}s'.format(0)) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Could not find skill UID or element id' } } log.close_logger(logger) return strategy order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['worldmap'] == 2: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed going through the portal from Incarnam to Astrub in {}s'. format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy execution_time = time.time() - global_start logger.info('Went from Astrub to Incarnam in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def change_map(**kwargs): """ A strategy make the bot move to an adjacent map. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) cell = strategy['parameters']['cell'] direction = strategy['parameters']['direction'] # 'n', 's', 'w', 'e' global_start, start = time.time(), time.time() report = strategies.move.move( strategy={ 'bot': strategy['bot'], 'command': 'move', 'parameters': { 'cell': cell } }, listener=listener, assets=assets, orders_queue=orders_queue )['report'] if not report['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'reason': 'Move failed'} } log.close_logger(logger) return strategy current_map_id = listener.game_state['map_id'] current_pos = '{};{}'.format(listener.game_state['pos'][0], listener.game_state['pos'][1]) map_data = strategies.support_functions.fetch_map(assets['map_info'], current_pos, listener.game_state['worldmap']) target_map_id = map_data['neighbours'][direction] order = { 'command': 'change_map', 'parameters': { 'direction': strategy['parameters']['direction'], 'target_map_id': target_map_id } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['map_id'] != current_map_id: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed changing map from {} through cell {} in {}s'.format(current_pos, cell, execution_time)) strategy['report'] = { 'success': False, 'details': {'Execution time': execution_time, 'Reason': 'Timeout'} } log.close_logger(logger) return strategy logger.info('Changed map from {} through cell {} in {}s'.format(current_pos, cell, execution_time)) strategy['report'] = { 'success': True, 'details': {'Execution time': execution_time} } log.close_logger(logger) time.sleep(0.5) return strategy
def harvest_duration(**kwargs): """ Harvests the resources on a path of maps for a specific duration :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() path = strategy['parameters']['path'] path_index = 0 total_haul = {} while time.time() - global_start < 60 * strategy['parameters']['duration']: sub_strategy = strategies.goto.goto( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'x': path[path_index]['pos'][0], 'y': path[path_index]['pos'][1], 'cell': path[path_index]['cell'] if 'cell' in path[path_index].keys() else None, 'worldmap': path[path_index]['worldmap'] if 'worldmap' in path[path_index].keys() else 1 } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy sub_strategy = strategies.harvest_map.harvest_map( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'whitelist': strategy['parameters']['whitelist'] if 'whitelist' in strategy['parameters'].keys() else None, 'blacklist': strategy['parameters']['blacklist'] if 'blacklist' in strategy['parameters'].keys() else None, } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy map_haul = sub_strategy['report']['details']['Collected'] for item_name, haul in map_haul.items(): if item_name in total_haul.keys(): total_haul[item_name] += haul else: total_haul[item_name] = haul if listener.game_state[ 'weight'] > listener.game_state['max_weight'] - 50: break sub_strategy = strategies.go_drop_bank.go_drop_bank( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'return': 'current' } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy path_index = (path_index + 1) % (len(path) - 1) logger.info('Harvested for {}s. Total haul: {}'.format( time.time() - global_start, total_haul)) strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start } } log.close_logger(logger) return strategy
def use_zaap(**kwargs): """ Uses a zaap to get to a specified destination The bot must be on a map with a zaap This strategy will move the bot to an appropriate cell to use the zaap :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() # Move the bot the appropriate cell to activate the zaap zaap_cell, element_id, skill_uid = None, None, None current_cell = listener.game_state['cell'] current_map = listener.game_state['pos'] for element in listener.game_state['map_elements']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys() and skill['skillId'] == 114: element_id = element['elementId'] zaap_cell = assets['elements_info'][str( listener.game_state['map_id'])][str( element_id)]['cell'] skill_uid = skill['skillInstanceUid'] if zaap_cell is None or element_id is None or skill_uid is None: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Could not find a Zaap at {}, map id : {}'.format( current_map, listener.game_state['map_id']) } } log.close_logger(logger) return strategy if not listener.game_state['in_haven_bag']: zaap_use_cell = strategies.support_functions.get_closest_walkable_neighbour_cell( assets['map_info'], zaap_cell, current_cell, current_map, listener.game_state['worldmap']) sub_strategy = strategies.move.move(listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'cell': zaap_use_cell } }, orders_queue=orders_queue, assets=assets) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Move to get to zaap failed' } } log.close_logger(logger) return strategy order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['zaap_dialog_open']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed to open zaap menu in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout when opening zaap menu' } } log.close_logger(logger) return strategy logger.info('Opened zaap menu in {}s'.format(execution_time)) target_map_id = int( strategies.support_functions.fetch_map( assets['map_info'], coord='{};{}'.format(strategy['parameters']['destination_x'], strategy['parameters']['destination_y']), worldmap=1)['id']) selected_destination = None for destination in listener.game_state['zaap_destinations']: if destination['mapId'] == target_map_id: selected_destination = destination if selected_destination is None: logger.warn('Zaap at destination [{},{}] is not known'.format( strategy['parameters']['destination_x'], strategy['parameters']['destination_y'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Zaap at destination [{},{}] is not known'.format( strategy['parameters']['destination_x'], strategy['parameters']['destination_y']) } } log.close_logger(logger) return strategy if selected_destination['cost'] > listener.game_state['kamas']: logger.warn( 'Not enough money to use zaap: needed {}, available: {}'.format( selected_destination['cost'], listener.game_state['kamas'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Not enough money to use zaap: needed {}, available: {}'. format(selected_destination['cost'], listener.game_state['kamas']) } } log.close_logger(logger) return strategy order = { 'command': 'travel_by_zaap', 'parameters': { 'target_map_id': selected_destination['mapId'] } } logger.info('Sending order to bot API: {}'.format(json.dumps(order))) orders_queue.put((json.dumps(order), )) waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if listener.game_state['map_id'] == selected_destination['mapId']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed to use zaap in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Teleport by zaap failed' } } log.close_logger(logger) return strategy strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def auctionh_get_all_prices(**kwargs): """ A strategy to get all the prices from the auction houses :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() n_new_entries = 0 path = [ (6, -17), (4, -17), (3, -19), ] if listener.game_state['sub_end'] != 0 and listener.game_state[ 'sub_end'] / 1000 - time.time() > 60 * 60 * 2: path = [(-30, -60), (-30, -53), (-27, -51), (-32, -55), (-36, -56)] sample_timestamp = int(time.time()) for pos in path: sub_strategy = goto.goto(assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'x': pos[0], 'y': pos[1] } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy sub_strategy = auctionh_get_prices.auctionh_get_prices( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { "general_ids_list": 'all', "sample_timestamp": sample_timestamp } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy n_new_entries += sub_strategy['report']['details'][ 'Number of new entries'] strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start, 'Number of new entries': n_new_entries } } log.close_logger(logger) return strategy
def bank_open(**kwargs): """ A strategy to open a bank :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() if listener.game_state['storage_open']: logger.info('Opened bank in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': { 'Execution time': 0 } } log.close_logger(logger) return strategy # Open NPC order = { 'command': 'open_npc', 'parameters': { 'map_id': listener.game_state['map_id'], 'npc_id': -20001, 'action_id': 3 } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['npc_dialog_open']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed to open NPC dialog in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Answer question order = { 'command': 'answer_npc', 'parameters': { 'reply_id': listener.game_state['npc_possible_replies'][0] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'storage_open' in listener.game_state.keys(): if listener.game_state['storage_open']: waiting = False time.sleep(0.05) if waiting: logger.warning('Failed to answer NPC to open storage in {}s'.format( execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to answer NPC to open storage in {}s'.format( execution_time) } } log.close_logger(logger) return strategy execution_time = time.time() - global_start logger.info('Opened bank in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def go_drop_bank(**kwargs): """ Go to the bank to drop what it holds :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() if 'parameters' in strategy.keys() and 'return' in strategy['parameters'].keys() and strategy['parameters']['return'] == 'current': strategy['parameters']['return'] = {'pos': listener.game_state['pos'], 'cell': listener.game_state['cell'], 'worldmap': listener.game_state['worldmap']} sub_strategy = strategies.goto.goto( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'x': 4, 'y': -18, 'worldmap': 1 } } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_enter.bank_enter( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_open.bank_open( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_put_items.bank_put_items( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'items': 'all' } } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_get_kamas.bank_get_kamas( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_close.bank_close( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy sub_strategy = strategies.bank_exit.bank_exit( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy if 'parameters' in strategy.keys() and 'return' in strategy['parameters'].keys() and strategy['parameters']['return'] is not None: sub_strategy = strategies.goto.goto( orders_queue=orders_queue, assets=assets, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'x': strategy['parameters']['return']['pos'][0], 'y': strategy['parameters']['return']['pos'][1], 'cell': strategy['parameters']['return']['cell'] if 'cell' in strategy['parameters']['return'].keys() else None, 'worldmap': strategy['parameters']['return']['worldmap'] if 'worldmap' in strategy['parameters']['return'].keys() else 1 } } ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': sub_strategy['report']} } log.close_logger(logger) return strategy logger.info('Dropped to bank in {}s'.format(time.time() - global_start)) strategy['report'] = { 'success': True, 'details': {'Execution time': time.time() - global_start} } log.close_logger(logger) return strategy
def path_ten(**kwargs): """ Walks around to get to level ten by earning successes :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() if listener.game_state['level'] >= 10: logger.info('Bot is already at least level 10') strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start } } log.close_logger(logger) return strategy path = [ { 'pos': [-2, -4], 'worldmap': 2 }, { 'pos': [-2, -2], 'worldmap': 2 }, { 'pos': [1, -2], 'worldmap': 2 }, { 'pos': [1, -4], 'worldmap': 2 }, { 'pos': [2, -14] }, { 'pos': [3, -14] }, { 'pos': [8, -15] }, { 'pos': [9, -25] }, { 'pos': [3, -32] }, { 'pos': [2, -27] }, { 'pos': [-3, -28] }, { 'pos': [-6, -29] }, { 'pos': [-5, -36] }, { 'pos': [-5, -47] }, { 'pos': [-8, -54] }, { 'pos': [-9, -54] }, { 'pos': [-15, -54] }, { 'pos': [-19, -56] }, { 'pos': [-19, -57] }, { 'pos': [-24, -62] }, { 'pos': [-28, -63] }, { 'pos': [-29, -60] }, { 'pos': [-27, -59] }, { 'pos': [-27, -55] }, { 'pos': [-27, -51] }, { 'pos': [-29, -53] }, { 'pos': [-30, -58] }, { 'pos': [-34, -53] }, { 'pos': [-34, -52] }, { 'pos': [-35, -52] }, { 'pos': [-35, -54] }, { 'pos': [-34, -59] }, { 'pos': [-29, -47] }, { 'pos': [-27, -34] }, { 'pos': [-25, -11] }, { 'pos': [-16, -3] }, { 'pos': [-18, -1] }, { 'pos': [-22, -1] }, { 'pos': [-24, 14] }, { 'pos': [-19, 23] }, { 'pos': [-22, 28] }, { 'pos': [-22, 29] }, { 'pos': [-27, 41] }, { 'pos': [-26, 40] }, { 'pos': [-24, 40] }, { 'pos': [-22, 40] }, { 'pos': [-20, 40] }, { 'pos': [-22, 37] }, { 'pos': [-24, 37] }, { 'pos': [-28, 37] }, { 'pos': [-29, 37] }, { 'pos': [-29, 34] }, { 'pos': [-27, 33] }, { 'pos': [-26, 33] }, ] for pos in path: sub_strategy = strategies.goto.goto( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'x': pos['pos'][0], 'y': pos['pos'][1], 'worldmap': pos['worldmap'] if 'worldmap' in pos.keys() else 1 } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy sub_strategy = strategies.achievement_reward.achievement_reward( assets=assets, orders_queue=orders_queue, listener=listener, strategy={'bot': strategy['bot']}) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy time.sleep(2) sub_strategy = strategies.achievement_reward.achievement_reward( assets=assets, orders_queue=orders_queue, listener=listener, strategy={'bot': strategy['bot']}) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy logger.info('Finished walking path 10 in {}s'.format(time.time() - global_start)) strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start } } log.close_logger(logger) return strategy
def auctionh_get_prices(**kwargs): """ A strategy to get prices from the auction house. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) ah_logger = ah_log.get_logger(__name__, strategy['bot'] + '_data') global_start, start = time.time(), time.time() n_new_entries = 0 sample_timestamp = int(time.time()) if 'sample_timestamp' in strategy['parameters']: sample_timestamp = strategy['parameters']['sample_timestamp'] # Check that the auction house is open. If it is, close it and open it again. # This is to prevent some edge case of item or type selection. See todos, lower in this script. if not listener.game_state['auction_house_info']: sub_strategy = strategies.auctionh_open.auctionh_open( listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], "parameters": { "mode": "buy" } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy else: sub_strategy = strategies.auctionh_close.auctionh_close( listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy sub_strategy = strategies.auctionh_open.auctionh_open( listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], "parameters": { "mode": "buy" } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy if 'parameters' in strategy.keys( ) and 'general_ids_list' in strategy['parameters']: if strategy['parameters']['general_ids_list'] not in [None, 'all']: ids = strategy['parameters']['general_ids_list'] else: ids = 'all' else: ids = 'all' all = False if ids == 'all': all = True actual_ids = [] for item_id, type_id in assets['id_2_type'].items(): if type_id in listener.game_state['auction_house_info'][ 'buyerDescriptor']['types']: item_level = assets['id_2_level'][str(item_id)] if item_level <= 60 or listener.game_state['sub_end']: actual_ids.append(int(item_id)) ids = actual_ids id_with_types = {} for item_id in ids: type_id = assets['id_2_type'][str(item_id)] if type_id in id_with_types.keys(): id_with_types[type_id].append(item_id) else: id_with_types[type_id] = [item_id] results = {} for type_id, item_ids in id_with_types.items(): previous_available_ids = listener.game_state['auction_house_info'][ 'items_available'] if 'items_available' in listener.game_state[ 'auction_house_info'].keys() else [] order = { "command": "auctionh_select_category", "parameters": { "category_id": type_id } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys( ) else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'auction_house_info' in listener.game_state.keys( ) and 'items_available' in listener.game_state[ 'auction_house_info']: # FIXME: This test is going to wrongly fail if asked to switch from a category to the same one if listener.game_state['auction_house_info'][ 'items_available'] != previous_available_ids: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn( 'Failed to change categories in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to change categories' } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy for item_id in item_ids: if item_id in listener.game_state['auction_house_info'][ 'items_available']: previous_available_ids = str( listener.game_state['auction_house_info']['item_selected'] [-1]) if 'item_selected' in listener.game_state[ 'auction_house_info'].keys() else [] order = { "command": "auctionh_select_item", "parameters": { "general_id": item_id } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys( ) else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'auction_house_info' in listener.game_state.keys( ) and 'item_selected' in listener.game_state[ 'auction_house_info']: # FIXME: This test is going to wrongly fail if asked to switch from an item to the same one if str(listener.game_state['auction_house_info'] ['item_selected'][-1]) != str( previous_available_ids): waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed to select item') strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to select item {}/{}'.format( item_id, assets['id_2_names'][str(item_id)]) } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy item_name = assets['id_2_names'][str(item_id)] object_type = 'item' if int( item_id ) in assets['hdv_2_id']['Equipements'] else 'resource' objects = listener.game_state['auction_house_info'][ 'actual_item_selected'] for object in objects: if object_type == 'item': formatted_object = { 'item_id': item_id, 'item_name': item_name, 'item_type': object_type, 'server': listener.game_state['server'], 'price_1': object['prices'][0], 'price_10': object['prices'][1], 'price_100': object['prices'][2], 'stats': object['effects'], 'hash': hashlib.sha256( (item_name + str(object['effects']) + str(object['prices'][0]) + str(object['prices'][1]) + str(object['prices'][2]) ).encode('utf8')).hexdigest(), 'sample_id': int(sample_timestamp) } if object_type == 'resource': formatted_object = { 'item_id': item_id, 'item_name': item_name, 'item_type': object_type, 'server': listener.game_state['server'], 'price_1': object['prices'][0], 'price_10': object['prices'][1], 'price_100': object['prices'][2], 'sample_id': int(sample_timestamp) } ah_logger.info( json.dumps(formatted_object, ensure_ascii=False)) n_new_entries += 1 results[item_id] = { 'item_name': assets['id_2_names'][str(item_id)], 'items_stats': listener.game_state['auction_house_info'] ['actual_item_selected'] } if all: strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start, 'Number of new entries': n_new_entries } } else: strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start, 'Results': results } } log.close_logger(logger) ah_log.close_logger(ah_logger) return strategy
def harvest_map(**kwargs): """ Uses a zaap to get to a specified destination The bot must be on a map with a zaap This strategy will move the bot to an appropriate cell to use the zaap :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() # Manage whitelist/blacklist if 'whitelist' in strategy['parameters'].keys() and \ strategy['parameters']['whitelist'] is not None and \ 'blacklist' in strategy['parameters'].keys() and \ strategy['parameters']['blacklist'] is not None: logger.warn( 'You can not have a whitelist and a blacklist at the same time') strategy['report'] = { 'success': False, 'details': { 'Reason': 'You can not have a whitelist and a blacklist at the same time' } } log.close_logger(logger) return strategy whitelist = strategy['parameters']['whitelist'] if 'whitelist' in strategy[ 'parameters'].keys() else None blacklist = strategy['parameters']['blacklist'] if 'blacklist' in strategy[ 'parameters'].keys() else None resource_cells = [] for element in listener.game_state['stated_elements']: resource_cells.append(element['elementCellId']) path = [] if len(resource_cells): closest, distance = resource_cells[0], support_functions.distance_cell( resource_cells[0], listener.game_state['cell']) for cell in resource_cells: if support_functions.distance_cell( cell, listener.game_state['cell']) < distance: closest, distance = cell, support_functions.distance_cell( cell, listener.game_state['cell']) path = [closest] del resource_cells[resource_cells.index(closest)] while len(resource_cells): closest, distance = resource_cells[0], support_functions.distance_cell( resource_cells[0], path[-1]) for cell in resource_cells: if support_functions.distance_cell(cell, path[-1]) < distance: closest, distance = cell, support_functions.distance_cell( cell, path[-1]) path.append(closest) del resource_cells[resource_cells.index(closest)] collected, failures, success = {}, [], 0 for cell in path: sub_strategy = strategies.harvest.harvest(listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'cell': cell, 'whitelist': whitelist, 'blacklist': blacklist } }, orders_queue=orders_queue, assets=assets) if sub_strategy['report']['success']: success += 1 for item, quantity in sub_strategy['report']['details'][ 'Collected'].items(): if item in collected.keys(): collected[item] += quantity else: collected[item] = quantity else: failures.append(sub_strategy['report']['details']['Reason']) execution_time = time.time() - global_start logger.info('Harvested {} on map {} in {}s'.format( collected, listener.game_state['pos'], execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time, 'Collected': collected, 'n_collected': success, 'failures_reasons': failures } } log.close_logger(logger) return strategy
def enter_dd_territory(**kwargs): """ A strategy to enter the DD territory using the stairs in the east. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() # Get the IDs for activating the steps element_id, skill_uid = None, None current_map = listener.game_state['pos'] for element in listener.game_state['map_elements']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys() and skill['skillId'] == 184: element_id = element['elementId'] skill_uid = skill['skillInstanceUid'] if element_id is None or skill_uid is None: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Could not find the stairs door at {}, map id : {}'.format( current_map, listener.game_state['map_id']) } } log.close_logger(logger) return strategy report = strategies.move.move(strategy={ 'bot': strategy['bot'], 'command': 'move', 'parameters': { 'cell': 387 } }, listener=listener, assets=assets, orders_queue=orders_queue)['report'] if not report['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'reason': 'Move failed' } } log.close_logger(logger) return strategy order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['pos'] == [-22, -1]: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn( 'Failed entering DD territory using the stairs in {}s'.format( execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy logger.info( 'Entered DD territory using the stairs in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def achievement_reward(**kwargs): """ A strategy to collect achievement rewards. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] logger = log.get_logger(__name__, strategy['bot']) if not len(listener.game_state['achievement_available']): logger.warn('No achievement available') strategy['report'] = { 'success': True, 'details': { 'Execution time': 0, 'Reason': 'No achievement available' } } log.close_logger(logger) return strategy order = { 'command': 'achievement_get', 'parameters': { 'actor_id': listener.game_state['actor_id'] } } achievements_list = listener.game_state['achievement_available'][:] logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if set(listener.game_state['achievement_available']) != set( achievements_list): waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn( 'Failed to get achievement reward in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy logger.info('Got achievement reward in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def auctionh_sell(**kwargs): """ Sells items at this map's auction house :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() # Establish the list of stuff to sell stuff_to_sell = {} for item in strategy['parameters']['items']: # If both a general and unique id are given if 'general_id' in item.keys() and item['general_id'] is not None and \ 'unique_id' in item.keys() and item['unique_id'] is not None: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'General id and unique id can not both be specified for an item' } } log.close_logger(logger) return strategy # If a general id is given if 'general_id' in item.keys() and item['general_id'] is not None: for inventory_item in listener.game_state['inventory']: if inventory_item['objectGID'] == item[ 'general_id'] and inventory_item['position'] == 63: item['name'] = assets['id_2_names'][str( inventory_item['objectGID'])] item['type'] = assets['id_2_type'][str( inventory_item['objectGID'])] item['level'] = assets['id_2_level'][str( inventory_item['objectGID'])] stuff_to_sell[inventory_item['objectUID']] = item # If a unique is is given if 'unique_id' in item.keys() and item['unique_id'] is not None: found = False for inventory_item in listener.game_state['inventory']: if inventory_item['objectUID'] == item['unique_id']: if inventory_item['position'] != 63: logger.warning( 'Item is currently worn and cannot be sold') strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Item is currently worn and cannot be sold' } } log.close_logger(logger) return strategy found = True item['name'] = assets['id_2_names'][str( inventory_item['objectGID'])] item['type'] = assets['id_2_type'][str( inventory_item['objectGID'])] item['level'] = assets['id_2_level'][str( inventory_item['objectGID'])] item['general_id'] = inventory_item['objectGID'] stuff_to_sell[inventory_item['objectUID']] = item if not found: logger.warning( 'Item specified by unique id could not be found in inventory' ) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Item specified by unique id could not be found in inventory' } } log.close_logger(logger) return strategy # Check quantities for uid, item in stuff_to_sell.items(): if 'quantity' not in item.keys() or item['quantity'] is None: item['quantity'] = 'all' available_in_inv = 0 for inventory_item in listener.game_state['inventory']: if inventory_item['objectUID'] == uid: available_in_inv = inventory_item['quantity'] break if item['quantity'] == 'all': item['quantity'] = available_in_inv // item['pack_size'] elif item['quantity'] * item['pack_size'] > available_in_inv: logger.warning( 'Not enough {}/{}. Requested {}, available {}'.format( uid, item['name'], item['quantity'] * item['pack_size'], available_in_inv)) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Not enough {}/{}. Requested {}, available {}'.format( uid, item['name'], item['quantity'] * item['pack_size'], available_in_inv) } } log.close_logger(logger) return strategy # Fill prices prices_to_check = [] for uid, item in stuff_to_sell.items(): if 'price' not in item.keys() or item['quantity'] is None: prices_to_check.append(item['general_id']) if len(prices_to_check): sub_strategy = strategies.auctionh_get_prices.auctionh_get_prices( assets=assets, orders_queue=orders_queue, listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'general_ids_list': prices_to_check } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy for gid, item in sub_strategy['report']['details']['Results'].items(): gid = int(gid) for uid, item_to_sell in stuff_to_sell.items(): if gid == item_to_sell[ 'general_id'] and 'price' not in item_to_sell.keys(): item_to_sell['price'] = item['items_stats'][0]['prices'][[ 1, 10, 100 ].index(item_to_sell['pack_size'])] - 1 # Check that the bot has enough money to sell total_fee = 0 for uid, item in stuff_to_sell.items(): total_fee += math.ceil(item['price'] * item['quantity'] * 0.02) if total_fee > listener.game_state['kamas']: logger.warning( 'Not enough money to sell items. Needed: {}, available: {}. Items to sell: {}' .format(total_fee, listener.game_state['kamas'], stuff_to_sell)) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Item specified by unique id could not be found in inventory' } } log.close_logger(logger) return strategy # Open the auction house if it is closed. if not listener.game_state[ 'auction_house_info'] or 'sellerDescriptor' not in listener.game_state[ 'auction_house_info'].keys(): sub_strategy = strategies.auctionh_open.auctionh_open( listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], "parameters": { "mode": "sell" } }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy # Check that the hdv has the level to sell these items for uid, item in stuff_to_sell.items(): if item['level'] > listener.game_state['auction_house_info'][ 'sellerDescriptor']['maxItemLevel']: logger.warning( 'Item {}/() is too high level for the {} auction house. Item level: {}, auction house max: {}' .format( item['general_id'], item['name'], listener.game_state['pos'], item['level'], listener.game_state['auction_house_info'] ['sellerDescriptor']['maxItemLevel'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Item {}/() is too high level for the {} auction house. Item level: {}, auction house max: {}' .format( item['general_id'], item['name'], listener.game_state['pos'], item['level'], listener.game_state['auction_house_info'] ['sellerDescriptor']['maxItemLevel']) } } log.close_logger(logger) return strategy # Check that the hdv can sell these items # TODO: test for uid, item in stuff_to_sell.items(): if item['type'] not in listener.game_state['auction_house_info'][ 'sellerDescriptor']['types']: logger.warning( 'Type {} can not be sold at the {} auction house'.format( item['type'], listener.game_state['pos'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Type {} can not be sold at the {} auction house'.format( item['type'], listener.game_state['pos']) } } log.close_logger(logger) return strategy # Check that the bot has enough slots available # TODO: test total_slots_needed = 0 for uid, item in stuff_to_sell.items(): total_slots_needed += item['quantity'] available_slots = listener.game_state['auction_house_info'][ 'sellerDescriptor']['maxItemPerAccount'] - len( listener.game_state['auction_house_info']['objectsInfos']) if total_slots_needed > available_slots: logger.warning( 'Not enough slots available to sell items. Needed: {}, available: {}. Items to sell: {}' .format(total_slots_needed, available_slots, stuff_to_sell)) strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Not enough slots available to sell items. Needed: {}, available: {}. Items to sell: {}' .format(total_slots_needed, available_slots, stuff_to_sell) } } log.close_logger(logger) return strategy # Sell stuff stuff_sold = {} for uid, item in stuff_to_sell.items(): for _ in range(item['quantity']): previous_item_quantity = None for inv_item in listener.game_state['inventory']: if inv_item['objectGID'] == item['general_id']: previous_item_quantity = inv_item['quantity'] order = { 'command': 'auctionh_sell_item', 'parameters': { 'unique_id': uid, 'quantity': item['pack_size'], 'price': item['price'] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys( ) else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: item_quantity = None for inv_item in listener.game_state['inventory']: if inv_item['objectGID'] == item['general_id']: item_quantity = inv_item['quantity'] if item_quantity != previous_item_quantity: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed to sell {}/{}, quantity: {}, price: {}'.format( item['general_id'], item['name'], item['pack_size'], item['price'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to sell {}:/}, quantity: {}, price: {}'.format( item['general_id'], item['name'], item['pack_size'], item['price']) } } log.close_logger(logger) return strategy logger.info('Sold {}/{}, quantity: {}, price: {}'.format( item['general_id'], item['name'], item['pack_size'], item['price'])) if uid in stuff_sold.keys(): stuff_sold[uid]['quantity'] += item['pack_size'] stuff_sold[uid]['total_price'] += item['price'] else: stuff_sold[uid] = { 'name': item['name'], 'general_id': item['general_id'], 'quantity': item['pack_size'], 'total_price': item['price'] } # Close auction house sub_strategy = strategies.auctionh_close.auctionh_close( listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy strategy['report'] = { 'success': True, 'details': { 'Execution time': time.time() - global_start, 'sold': stuff_sold } } log.close_logger(logger) return strategy
def go_to_astrub(**kwargs): """ A strategy to go from Incarnam to Astrub trough the portal :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() # Open NPC order = { 'command': 'open_npc', 'parameters': { 'map_id': listener.game_state['map_id'], 'npc_id': -20000, 'action_id': 3 } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['npc_dialog_open']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed to open NPC dialog in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Answer first question order = { 'command': 'answer_npc', 'parameters': { 'reply_id': listener.game_state['npc_possible_replies'][0] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['npc_current_question'] in [30639, 30638]: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed answering first question in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Answer second question order = { 'command': 'answer_npc', 'parameters': { 'reply_id': listener.game_state['npc_possible_replies'][0] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys(): if listener.game_state['pos'] == [6, -19]: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed answering second question in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Go to cell 548 order = { 'command': 'move', 'parameters': { "isUsingNewMovementSystem": False, "cells": [[True, False, 0, 0, True, 0] for _ in range(560)], "target_cell": 548 } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if listener.game_state['cell'] == 548: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed going to cell 548 in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy # Change map to 192416777 order = { 'command': 'change_map', 'parameters': { 'target_map_id': 192416777 } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if listener.game_state['map_id'] == 191106048: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warning( 'Failed going to cell 468 in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy logger.info('Went from Incarnam to Astrub in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def bank_get_kamas(**kwargs): """ A strategy to get kamas from the bank :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() kamas_to_transfer = 'all' if 'parameters' in strategy.keys() and 'quantity' in strategy['parameters'].keys() and strategy['parameters']['quantity'] is not None: kamas_to_transfer = strategy['parameters']['quantity'] if not listener.game_state['storage_open']: logger.warning('Bank is not open') strategy['report'] = { 'success': False, 'details': {'Execution time': 0, 'Reason': 'Bank is not open'} } log.close_logger(logger) return strategy kamas_in_storage = listener.game_state['storage_content']['kamas'] kamas_to_transfer = kamas_in_storage if kamas_to_transfer == 'all' else kamas_to_transfer if kamas_to_transfer > kamas_in_storage: logger.warning('Cannot get {} kamas from bank, only {} are available'.format(kamas_to_transfer, kamas_in_storage)) strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - global_start, 'Reason': 'Cannot get {} kamas from bank, only {} are available'.format(kamas_to_transfer, kamas_in_storage)} } log.close_logger(logger) return strategy if kamas_to_transfer == 0: logger.info('No kamas to transfer') strategy['report'] = { 'success': True, 'details': {'Execution time': time.time() - global_start} } log.close_logger(logger) return strategy kamas_before = listener.game_state['kamas'] order = { "command": "move_kamas", "parameters": { "quantity": -kamas_to_transfer } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'kamas' in listener.game_state.keys(): if listener.game_state['kamas'] != kamas_before: waiting = False time.sleep(0.05) execution_time = time.time() - global_start if waiting: logger.warning('Failed to get {} kamas from bank in {}s'.format(kamas_to_transfer, execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to get {} from bank in {}s'.format(kamas_to_transfer, execution_time) } } log.close_logger(logger) return strategy logger.info('{} kamas transferred from bank to inventory'.format(kamas_to_transfer)) strategy['report'] = { 'success': True, 'details': {'Execution time': time.time() - global_start} } log.close_logger(logger) return strategy
def enter_havenbag(**kwargs): """ A strategy to enter the haven bag. Checks if the player is level > 10 and if it's already inside. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] logger = log.get_logger(__name__, strategy['bot']) if listener.game_state['level'] < 10: logger.warn('Bot level too low') strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Bot level too low' } } log.close_logger(logger) return strategy if listener.game_state['sub_end'] < time.time(): logger.warn('Bot not subscribed') strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': 'Bot not subscribed' } } log.close_logger(logger) return strategy if 'in_haven_bag' in listener.game_state.keys(): if listener.game_state['in_haven_bag']: logger.info('Entered havenbag in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': { 'Execution time': 0 } } log.close_logger(logger) return strategy order = {'command': 'enter_havenbag'} logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'in_haven_bag' in listener.game_state.keys(): if listener.game_state['in_haven_bag']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed entering havenbag in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy logger.info('Entered havenbag in {}s'.format(execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def move(**kwargs): """ A strategy move the bot within a map. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start = time.time() # Close the auction house if it is open if len(listener.game_state['auction_house_info']): sub_strategy = auctionh_close.auctionh_close(listener=listener, orders_queue=orders_queue, assets=assets, strategy={ "bot": strategy['bot'], }) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - global_start, 'Reason': sub_strategy['report'] } } log.close_logger(logger) return strategy if 'cell' in listener.game_state.keys(): if listener.game_state['cell'] == strategy['parameters']['cell']: logger.info('Completed move to cell {} in {}s'.format( strategy['parameters']['cell'], 0)) strategy['report'] = { 'success': True, 'details': { 'Execution time': 0 } } log.close_logger(logger) return strategy current_pos = '{};{}'.format(listener.game_state['pos'][0], listener.game_state['pos'][1]) map_data = support_functions.fetch_map(assets['map_info'], current_pos, listener.game_state['worldmap']) deserialized_raw_cells = [] for cell in map_data['rawCells']: deserialized_raw_cells.append( ast.literal_eval(assets['map_info_index'][cell])) order = { 'command': 'move', 'parameters': { "isUsingNewMovementSystem": map_data['isUsingNewMovementSystem'], "cells": deserialized_raw_cells, "target_cell": strategy['parameters']['cell'] } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 20 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if listener.game_state['cell'] == strategy['parameters']['cell']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed moving to cell {} in {}s'.format( strategy['parameters']['cell'], execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout, no map movement for bot' } } log.close_logger(logger) return strategy start = time.time() timeout = 20 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'pos' in listener.game_state.keys( ) and 'worldmap' in listener.game_state.keys(): if not listener.game_state['currently_walking']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed moving to cell {} in {}s'.format( strategy['parameters']['cell'], execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout, no movement confirmation' } } log.close_logger(logger) return strategy logger.info('Completed move to cell {} in {}s'.format( strategy['parameters']['cell'], time.time() - global_start)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy
def bank_enter(**kwargs): """ A strategy to enter a bank :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) global_start, start = time.time(), time.time() if listener.game_state['worldmap'] == -1: logger.info('Already inside bank (or at least underground) in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': {'Execution time': 0} } log.close_logger(logger) return strategy # Move the bot the appropriate cell to activate the zaap door_cell, element_id, skill_uid = None, None, None current_cell = listener.game_state['cell'] current_map = listener.game_state['pos'] for element in listener.game_state['map_elements']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys() and skill['skillId'] == 184: element_id = element['elementId'] door_cell = assets['elements_info'][str(listener.game_state['map_id'])][str(element_id)]['cell'] skill_uid = skill['skillInstanceUid'] if door_cell is None or element_id is None or skill_uid is None: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': 'Could not find a Zaap at {}, map id : {}'.format(current_map, listener.game_state['map_id'])} } log.close_logger(logger) return strategy door_use_cell = strategies.support_functions.get_closest_walkable_neighbour_cell(assets['map_info'], door_cell, current_cell, current_map, listener.game_state['worldmap']) sub_strategy = strategies.move.move( listener=listener, strategy={'bot': strategy['bot'], 'parameters': {'cell': door_use_cell}}, orders_queue=orders_queue, assets=assets ) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': {'Execution time': time.time() - start, 'Reason': 'Move to get to door failed'} } log.close_logger(logger) return strategy order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order),)) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['worldmap'] == -1: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed to open bank door in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': {'Execution time': execution_time, 'Reason': 'Failed to open bank door in {}s'.format(execution_time)} } log.close_logger(logger) return strategy logger.info('Entered bank in {}s'.format(execution_time)) execution_time = time.time() - global_start strategy['report'] = { 'success': True, 'details': {'Execution time': execution_time} } log.close_logger(logger) return strategy
def harvest(**kwargs): """ Harvests a cell's resources after checking that it can. :param kwargs: :return: report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] resource_cell = strategy['parameters']['cell'] logger = log.get_logger(__name__, strategy['bot']) start, global_start = time.time(), time.time() # Manage whitelist/blacklist if 'whitelist' in strategy['parameters'].keys() and \ strategy['parameters']['whitelist'] is not None and \ 'blacklist' in strategy['parameters'].keys() and \ strategy['parameters']['blacklist'] is not None: logger.warn( 'You can not have a whitelist and a blacklist at the same time') strategy['report'] = { 'success': False, 'details': { 'Reason': 'You can not have a whitelist and a blacklist at the same time' } } log.close_logger(logger) return strategy if 'whitelist' in strategy['parameters'].keys( ) and strategy['parameters']['whitelist'] is not None: whitelist = strategy['parameters']['whitelist'] elif 'blacklist' in strategy['parameters'].keys( ) and strategy['parameters']['blacklist'] is not None: whitelist = [ int(key) for key in assets['id_2_names'].keys() if key not in strategy['parameters']['blacklist'] ] else: whitelist = [int(key) for key in assets['id_2_names'].keys()] # Check if the cell has an available resource element_id = None for element in listener.game_state['stated_elements']: if element['elementCellId'] == resource_cell: element_id = element['elementId'] if element_id is None: logger.warn('Did not find a resource at cell {} in {}s'.format( resource_cell, 0)) strategy['report'] = { 'success': False, 'details': { 'Reason': 'Did not find a resource at cell {} in {}s'.format( resource_cell, 0) } } log.close_logger(logger) return strategy skill_id, skill_uid = None, None for element in listener.game_state['map_elements']: if element_id == element['elementId']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys(): skill_id = skill['skillId'] skill_uid = skill['skillInstanceUid'] if skill_id is None: logger.warn( 'Resource at cell {} is not harvestable'.format(resource_cell)) strategy['report'] = { 'success': False, 'details': { 'Reason': 'Resource at cell {} is not harvestable'.format(resource_cell) } } log.close_logger(logger) return strategy # Check if the resource is whitelisted for skill in assets['Skills']: if skill['id'] == skill_id and skill[ 'gatheredRessourceItem'] not in whitelist: logger.warn( 'Resource ({}/{}) at cell {} is not whitelisted'.format( skill['gatheredRessourceItem'], assets['id_2_names'][str(skill['gatheredRessourceItem'])], resource_cell)) strategy['report'] = { 'success': False, 'details': { 'Reason': 'Resource ({}/{}) at cell {} is not whitelisted'.format( skill['gatheredRessourceItem'], assets['id_2_names'][str( skill['gatheredRessourceItem'])], resource_cell) } } log.close_logger(logger) return strategy # Check if the player has the skill level to harvest it required_skill_level, range = None, None for skill in assets['Skills']: if skill['id'] == skill_id: required_skill_level = skill['levelMin'] range = skill['range'] if required_skill_level is None: logger.warn('Skill id not found') strategy['report'] = { 'success': False, 'details': { 'Reason': 'Skill id not found' } } log.close_logger(logger) return strategy bot_skill_level = None for job_id, job in listener.game_state['jobs'].items(): for skill in job['skills']: if skill['skillId'] == skill_id: bot_skill_level = job['jobLevel'] if bot_skill_level is None: logger.warn('Could not determine bot skill level') strategy['report'] = { 'success': False, 'details': { 'Reason': 'Could not determine bot skill level' } } log.close_logger(logger) return strategy if bot_skill_level < required_skill_level: logger.warn('Bot skill level insufficient') strategy['report'] = { 'success': False, 'details': { 'Reason': 'Bot skill level insufficient' } } log.close_logger(logger) return strategy # TODO: remove this after fight is implemented if bot_skill_level > 19: logger.warn('Bot skill level too high') strategy['report'] = { 'success': False, 'details': { 'Reason': 'Bot skill level too high' } } log.close_logger(logger) return strategy # Check if the player can reach the resource i.e. skill range >= manhattan distance between closest reachable cell and resource cell closest_reachable_cell = support_functions.get_closest_reachable_cell( assets['map_info'], resource_cell, listener.game_state['cell'], listener.game_state['pos'], listener.game_state['worldmap']) dist = sum([ abs(a - b) for a, b in zip(support_functions.cell_2_coord(closest_reachable_cell), support_functions.cell_2_coord(resource_cell)) ]) if dist > range: logger.warn('Resource out of range') strategy['report'] = { 'success': False, 'details': { 'Reason': 'Resource out of range' } } log.close_logger(logger) return strategy # Move the bot the appropriate cell to use the resource sub_strategy = strategies.move.move(listener=listener, strategy={ 'bot': strategy['bot'], 'parameters': { 'cell': closest_reachable_cell } }, orders_queue=orders_queue, assets=assets) if not sub_strategy['report']['success']: strategy['report'] = { 'success': False, 'details': { 'Execution time': time.time() - start, 'Reason': 'Move to get to resource harvest spot failed' } } log.close_logger(logger) return strategy # Check if the resource is still available element_id = None for element in listener.game_state['stated_elements']: if element['elementCellId'] == resource_cell: element_id = element['elementId'] if element_id is None: logger.warn('Did not find a resource at cell {} in {}s'.format( resource_cell, 0)) strategy['report'] = { 'success': False, 'details': { 'Reason': 'Did not find a resource at cell {} in {}s'.format( resource_cell, 0) } } log.close_logger(logger) return strategy skill_id, skill_uid = None, None for element in listener.game_state['map_elements']: if element_id == element['elementId']: if 'enabledSkills' in element.keys(): for skill in element['enabledSkills']: if 'skillId' in skill.keys(): skill_id = skill['skillId'] skill_uid = skill['skillInstanceUid'] if skill_id is None: logger.warn( 'Resource at cell {} is not harvestable'.format(resource_cell)) strategy['report'] = { 'success': False, 'details': { 'Reason': 'Resource at cell {} is not harvestable'.format(resource_cell) } } log.close_logger(logger) return strategy # # --------------------------------------- # # TODO: temporary blocking of harvest operation to check if that's the source of bans # strategy['report'] = { # 'success': True, # 'details': { # 'Execution time': time.time() - global_start, # 'Collected': {} # } # } # # log.close_logger(logger) # return strategy # # --------------------------------------- # harvest inventory_before_harvest = json.loads( json.dumps(listener.game_state['inventory'])) order = { 'command': 'use_interactive', 'parameters': { 'element_id': element_id, 'skill_uid': skill_uid } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['harvest_started']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed to start harvest in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Failed to start harvest in {}s'.format(execution_time) } } log.close_logger(logger) return strategy start = time.time() timeout = 10 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if listener.game_state['harvest_done']: waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn( 'Harvest started but did not end ? in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Harvest started but did not end ? in {}s'.format( execution_time) } } log.close_logger(logger) return strategy collected = {} inventory_after_harvest = json.loads( json.dumps(listener.game_state['inventory'])) for item in inventory_after_harvest: was_in_inventory = False for item_before in inventory_before_harvest: if item['objectUID'] == item_before['objectUID']: was_in_inventory = True if item['quantity'] != item_before['quantity']: if assets['id_2_names'][str( item['objectGID'])] in collected.keys(): collected[assets['id_2_names'][str( item['objectGID'] )]] += item['quantity'] - item_before['quantity'] else: collected[assets['id_2_names'][str( item['objectGID'] )]] = item['quantity'] - item_before['quantity'] if not was_in_inventory: collected[assets['id_2_names'][str( item['objectGID'])]] = item['quantity'] logger.info('Harvested {} in {}s'.format(collected, execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time, 'Collected': collected } } log.close_logger(logger) return strategy
def connect(**kwargs): """ A strategy to connect a bot. :param kwargs: strategy, listener, and orders_queue :return: the input strategy with a report """ strategy = kwargs['strategy'] listener = kwargs['listener'] orders_queue = kwargs['orders_queue'] assets = kwargs['assets'] logger = log.get_logger(__name__, strategy['bot']) if support_functions.get_profile(strategy['bot'])['banned']: logger.warning('{} has been banned'.format(strategy['bot'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': 0, 'Reason': '{} has been banned'.format(strategy['bot']) } } log.close_logger(logger) return strategy if 'connected' in listener.game_state.keys(): if listener.game_state['connected']: logger.info('Bot connected in {}s'.format(0)) strategy['report'] = { 'success': True, 'details': { 'Execution time': 0 } } log.close_logger(logger) return strategy bot_profile = strategies.support_functions.get_profile(strategy['bot']) order = { 'command': 'connect', 'parameters': { 'name': bot_profile['name'], 'username': bot_profile['username'], 'password': bot_profile['password'], 'serverId': assets['server_2_id'][bot_profile['server']], } } logger.info('Sending order to bot API: {}'.format(order)) orders_queue.put((json.dumps(order), )) start = time.time() timeout = 40 if 'timeout' not in strategy.keys() else strategy['timeout'] waiting = True while waiting and time.time() - start < timeout: if 'connected' in listener.game_state.keys( ) and 'api_outdated' in listener.game_state.keys(): if 'pos' in listener.game_state.keys() or listener.game_state[ 'api_outdated'] or listener.game_state['banned']: # Actually wait for the map to load and not just a connection confirmation waiting = False time.sleep(0.05) execution_time = time.time() - start if waiting: logger.warn('Failed connecting in {}s'.format(execution_time)) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Timeout' } } log.close_logger(logger) return strategy if listener.game_state['api_outdated']: logger.warn( 'Your BlackFalconAPI is outdated. Try to get the latest one or contact the BlackFalcon team if you already have the latest version' ) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': 'Your BlackFalconAPI is outdated. Try to get the latest one or contact the BlackFalcon team if you already have the latest version' } } log.close_logger(logger) return strategy if listener.game_state['banned']: logger.warn('{} has been banned'.format(strategy['bot'])) strategy['report'] = { 'success': False, 'details': { 'Execution time': execution_time, 'Reason': '{} has been banned'.format(strategy['bot']) } } log.close_logger(logger) return strategy logger.info('Connected {} in {}s'.format(strategy['bot'], execution_time)) strategy['report'] = { 'success': True, 'details': { 'Execution time': execution_time } } log.close_logger(logger) return strategy