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
