def get_minion_data_split(boxes, stage):
logging.info("[ENTER] get_minion_data_split")
potential_data = []
result_data = []
for box in boxes:
c_box = defines.c(box) # get a new reference so the defines list isn't permanently changed
potential_data.append([])
for src_pass in range(0, 20):
# print c_box
src = screen_cap(box=c_box)
mask_result = minion_data_mask(src, None, stage)
txt_result = minion_data_to_string(mask_result)
try:
potential_data[-1].append(int(txt_result))
except:
potential_data[-1].append(" ")
potential_mode = countdict(potential_data[-1], limit=5)
if potential_mode >= 0:
if potential_data[-1][-1] != "":
result_data.append(potential_data[-1][-1])
break
return result_data
def get_minion_data_split(boxes, stage):
logging.info("[ENTER] get_minion_data_split")
potential_data = []
result_data = []
for box in boxes:
c_box = defines.c(
box
) #get a new reference so the defines list isn't permanently changed
potential_data.append([])
for src_pass in range(0, 20):
#print c_box
src = screen_cap(box=c_box)
mask_result = minion_data_mask(src, None, stage)
txt_result = minion_data_to_string(mask_result)
try:
potential_data[-1].append(int(txt_result))
except:
potential_data[-1].append(' ')
potential_mode = countdict(potential_data[-1], limit=5)
if potential_mode >= 0:
if potential_data[-1][-1] != '':
result_data.append(potential_data[-1][-1])
break
return result_data
def get_state(src, sigs):
logging.info("[ENTER] get_state")
min_emd = 9999999.99
min_f = ""
src = np_to_img(src)
for f in sigs:
box = defines.c(defines.state_box[defines.state_dict[f[:-4]]])
emd = calc_emd_pre_calculated_src2(src[box[1] : box[3], box[0] : box[2]], sigs[f])
if emd < min_emd:
min_emd = emd
min_f = f
return min_f[:-4]
def get_state(src, sigs):
logging.info("[ENTER] get_state")
min_emd = 9999999.99
min_f = ''
src = np_to_img(src)
for f in sigs:
box = defines.c(defines.state_box[defines.state_dict[f[:-4]]])
emd = calc_emd_pre_calculated_src2(src[box[1]:box[3], box[0]:box[2]],
sigs[f])
if emd < min_emd:
min_emd = emd
min_f = f
return min_f[:-4]
def get_state_sift(src, descs, ignore_list=[]):
logging.info("[ENTER] get_state_sift")
max_good = 0
max_f = None
for f in descs:
if f not in ignore_list:
box = defines.c(defines.state_box[defines.state_dict[f[:-4]]])
good = calc_sift_precaculated_src2(src[box[1] : box[3], box[0] : box[2]], descs[f])
if good > max_good:
max_good = good
max_f = f
if max_f != None:
return max_f[:-4]
else:
return None
def get_state_sift(src, descs, ignore_list=[]):
logging.info("[ENTER] get_state_sift")
max_good = 0
max_f = None
for f in descs:
if f not in ignore_list:
box = defines.c(defines.state_box[defines.state_dict[f[:-4]]])
good = calc_sift_precaculated_src2(
src[box[1]:box[3], box[0]:box[2]], descs[f])
if good > max_good:
max_good = good
max_f = f
if max_f != None:
return max_f[:-4]
else:
return None
def player():
global src
global NEW_GAME, opponent_char, player_char, stage, current_decknum
logging.info("[ENTER] player")
control_success = (
True
) # keep track of whether or not the bot was able to control the mouse. If not the user is attempting to use it
actions.pause_pensively(1)
if NEW_GAME:
src = vision.screen_cap()
stage = vision.get_image_info_sift(src, stage_descs, c(defines.stage_box))
NEW_GAME = False
# logging.info("------GET MATCH INFO------")
src = vision.screen_cap()
if player_char == None:
try:
player_char = vision.get_image_info_sift(src, character_descs, c(defines.player_box))
except:
player_char = None
if stage == None:
try:
stage = vision.get_image_info_sift(src, stage_descs, c(defines.stage_box))
except:
stage = None
# logging.info("---ATTACK WITH CHARACTER---")
actions.pause_pensively(0.25)
src = vision.screen_cap()
player_attack = vision.color_range_reduced_mids(src, c(defines.reduced_player_box), color="green")
if player_attack and control_success:
control_success = actions.move_and_leftclick(c(defines.neutral_minion))
control_success = actions.move_and_leftclick(c(defines.player_hero))
# actions.move_cursor([player_attack[0][0],player_attack[0][1]+10])
actions.pause_pensively(0.1)
src = vision.screen_cap()
enemy = []
enemy.extend(vision.color_range_reduced_mids(src, c(defines.reduced_opponent_box1), color="red"))
enemy.extend(vision.color_range_reduced_mids(src, c(defines.reduced_opponent_box2), color="red"))
enemy_minions = vision.get_taunt_minions(src, c(defines.enemy_minions_box_taunts))
if enemy_minions:
e_m = randint(0, len(enemy_minions) - 1) # attack a random taunt minion
if enemy_minions:
control_success = actions.move_and_leftclick(enemy_minions[e_m])
elif enemy:
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
else:
# something's wrong, try to attack any minion
actions.pause_pensively(6)
enemy_minions = vision.color_range_reduced_mids(src, c(defines.reduced_enemy_minions_box), color="red")
if enemy_minions:
control_success = actions.move_and_leftclick(enemy_minions[0])
control_success = actions.move_and_leftclick(c(defines.neutral))
# logging.info("------PLAY CARDS------")
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_cards_combo = vision.get_playable_cards(src, c(defines.hand_box), color="yellow")
if player_cards_combo and player_char == "rogue": # active combo cards are played before non-combo cards
player_cards = player_cards_combo
while player_cards and control_success:
control_success = actions.move_and_leftclick(player_cards[weighted_randint(len(player_cards))])
actions.move_cursor(c(defines.nuetral_targeting))
src = vision.screen_cap()
targeting = vision.color_range_reduced_mids(src, c(defines.nuetral_targeting_box), color="red_targeting")
if targeting:
if defines.TARGETING[current_decknum] == defines.Target.OPPONENT_HERO:
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
if defines.TARGETING[current_decknum] == defines.Target.OPPONENT_HERO:
actions.move_and_leftclick(c(defines.play_card[randint(0, len(defines.play_card) - 1)]))
actions.move_cursor(c(defines.nuetral_targeting))
src = vision.screen_cap()
targeting = vision.color_range_reduced_mids(src, c(defines.nuetral_targeting_box), color="red_targeting")
if targeting:
if defines.TARGETING[current_decknum] == defines.Target.OPPONENT_HERO:
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
actions.pause_pensively(1.5)
src = vision.screen_cap()
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_cards_combo = vision.get_playable_cards(src, c(defines.hand_box), color="yellow")
if player_cards_combo: # active combo cards are played before non-combo cards
player_cards = player_cards_combo
if not actions.check_game("Hearthstone"):
break
# logging.info("------PLAY ABILITY------")
actions.pause_pensively(0.50)
src = vision.screen_cap()
player_ability = vision.color_range_reduced_mids(src, c(defines.reduced_ability_box), color="green")
if player_ability and player_char and control_success:
if player_char == "mage":
control_success = actions.move_and_leftclick(c(defines.player_ability))
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
elif player_char == "priest":
control_success = actions.move_and_leftclick(c(defines.player_ability))
control_success = actions.move_and_leftclick(c(defines.player_hero))
else:
control_success = actions.move_and_leftclick(c(defines.player_ability))
control_success = actions.move_and_leftclick(c(defines.neutral_minion))
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
actions.pause_pensively(2)
player_ability = 0
# logging.info("---ATTACK WITH MINIONS---")
src = vision.screen_cap()
player_minions = vision.color_range_reduced_mids(
src, c(defines.reduced_player_minions_box), color="green", min_threshold=45, max_threshold=200
)
while player_minions and control_success:
p_m = False
no_enemy_taunts_detected = True
min_subset = [False, 99]
src = vision.screen_cap()
enemy_minions = vision.get_taunt_minions(src, c(defines.enemy_minions_box_taunts))
if enemy_minions:
no_enemy_taunts_detected = False
if defines.RANDOM_ATTACKS or defines.ref_game_screen_res_list[defines.GAME_SCREEN_RES] == [1400, 1050]:
p_m = player_minions[randint(0, len(player_minions) - 1)] # attack with a random minion
e_m = enemy_minions[randint(0, len(enemy_minions) - 1)] # attack a random taunt minion
else:
if control_success:
player_minions_data = vision.all_minion_data(
src,
defines.player_minion_data_split,
defines.c(defines.player_minions_box),
minions_box_playable=defines.c(defines.reduced_player_minions_box),
stage=stage,
)
enemy_minions_data = vision.all_minion_data(
src,
defines.enemy_minion_data_split,
defines.c(defines.enemy_minions_box),
minions_box_taunts_reduced=c(defines.reduced_enemy_minions_box),
minions_box_taunts=defines.c(defines.enemy_minions_box_taunts),
stage=stage,
reduced_color="red",
)
# print ''
# for i in range(0,len(enemy_minions_data)):
# print enemy_minions_data[i]
# print ""
# for i in range(0,len(player_minions_data)):
# print player_minions_data[i]
playable_minions = []
for player_minion in player_minions_data:
if player_minion["playable"] == True:
playable_minions.append(player_minion)
if playable_minions == []:
break
taunt_minions = []
for enemy_minion in enemy_minions_data:
if enemy_minion["taunt"] == True:
taunt_minions.append(enemy_minion)
subsets = []
for L in range(0, len(playable_minions) + 1):
for subset in combinations(playable_minions, L):
attack_total = 0
for individual in subset:
if "attack" in individual:
if individual["attack"] != " ":
attack_total += int(individual["attack"])
if subset:
subsets.append([subset, attack_total])
min_subset = [False, 99]
# max_taunt = 0
min_difference = 99
for taunt_minion in taunt_minions:
# if taunt_minion['defense']>max_taunt[0]:
# max_taunt=taunt_minion['defense']
if "defense" in taunt_minion:
if taunt_minion["defense"] == " ":
taunt_minion["defense"] = "5"
else:
taunt_minion["defense"] = "5"
for subset in subsets:
difference = abs(subset[1] - int(taunt_minion["defense"]))
if (
subset[1] >= taunt_minion["defense"]
and difference < min_difference
and (subset[1] < min_subset[1] or len(subset) < len(min_subset))
): # attack_total > taunt defense
min_subset = subset
min_difference = difference
p_m = min_subset[0][0]["coord"]
e_m = taunt_minion["coord"]
if p_m == False:
p_m = player_minions[randint(0, len(player_minions) - 1)] # attack with a random minion
e_m = enemy_minions[randint(0, len(enemy_minions) - 1)] # attack a random taunt minion
# print 'Use subset: ',min_subset
else:
no_enemy_taunts_detected = True
if len(player_minions) > 1:
p_m = player_minions[randrange(0, len(player_minions) - 1)]
else:
p_m = player_minions[0]
control_success = actions.move_and_leftclick(p_m)
actions.move_cursor(
[p_m[0], p_m[1] + int(150 * float(defines.game_screen_res[1]) / float(defines.ref_game_screen_res[1]))]
)
actions.pause_pensively(0.2)
src = vision.screen_cap()
enemy = []
enemy_freeze = None
enemy.extend(vision.color_range_reduced_mids(src, c(defines.reduced_opponent_box1), color="red"))
enemy.extend(vision.color_range_reduced_mids(src, c(defines.reduced_opponent_box2), color="red"))
enemy_freeze = vision.color_range_reduced_mids(src, c(defines.reduced_opponent_box1), color="blue")
enemy_minions = vision.get_taunt_minions(src, c(defines.enemy_minions_box_taunts))
if enemy_minions and no_enemy_taunts_detected: # something wrong has happened, try a bunch of stuff
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
actions.pause_pensively(2)
control_success = actions.move_and_leftclick(p_m)
actions.move_cursor(
[p_m[0], p_m[1] + int(150 * float(defines.game_screen_res[1]) / float(defines.ref_game_screen_res[1]))]
)
actions.pause_pensively(0.2)
e_m = enemy_minions[randint(0, len(enemy_minions) - 1)] # attack a random taunt minion
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
actions.pause_pensively(2.5)
elif enemy_minions:
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
actions.pause_pensively(2.5)
elif enemy:
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
elif enemy_freeze:
control_success = actions.move_and_leftclick(c(defines.opponent_hero))
else:
# something's wrong, try to attack any minion
actions.pause_pensively(6)
enemy_minions = vision.color_range_reduced_mids(src, c(defines.reduced_enemy_minions_box), color="red")
if enemy_minions:
e_m = enemy_minions[randint(0, len(enemy_minions) - 1)] # attack a random taunt minion
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
actions.pause_pensively(2.5)
else:
actions.pause_pensively(6)
control_success = actions.move_and_rightclick(c(defines.neutral_minion))
src = vision.screen_cap()
state_name = vision.get_state_sift(
src,
state_descs,
ignore_list=[
"versus.png",
"defeat.png",
"finding_opponent.png",
"gold.png",
"opponent_still_choosing.png",
"starting_hand.png",
"rank.png",
"victory.png",
],
)
if state_name == "play":
break
if not actions.check_game("Hearthstone"):
break
player_minions = vision.color_range_reduced_mids(
src, c(defines.reduced_player_minions_box), color="green", min_threshold=45, max_threshold=200
)
# logging.info("------PLAY INFO CHECK-------")
actions.pause_pensively(0.25)
src = vision.screen_cap()
state_name = vision.get_state_sift(src, state_descs)
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_ability = vision.color_range_reduced_mids(src, c(defines.reduced_ability_box), color="green")
if (
player_ability
): # player ability still shows up even though we've past that section above, chances are the character is wrong
try:
player_char = vision.get_image_info_sift(src, character_descs, c(defines.player_box))
except:
player_char = None
player_minions = vision.color_range_reduced_mids(
src, c(defines.reduced_player_minions_box), color="green", min_threshold=45, max_threshold=200
)
player_attack = vision.color_range_reduced_mids(src, c(defines.reduced_player_box), color="green")
if (
(player_cards == [] and player_ability == [] and player_minions == [] and player_attack == [])
or player_cards == None
or player_ability == None
or player_minions == None
or player_attack == None
and control_success
and (
state_name == defines.State.PLAYER
or state_name == defines.State.OPPONENT
or state_name == defines.State.PLAYER_GREEN
)
):
# logging.info("---END TURN---")
control_success = actions.move_and_leftclick(c(defines.neutral))
player_turn_green_check = vision.color_range_reduced_mids(src, c(defines.turn_box), color="green")
if player_turn_green_check != [] and player_turn_green_check != None and control_success:
control_success = actions.move_and_leftclick(c(defines.turn_button))
control_success = actions.move_and_leftclick(c(defines.neutral))
else:
actions.pause_pensively(5)
player_end()
def all_minion_data(
src,
minion_data_boxes,
minions_box,
minions_box_taunts_reduced=None,
minions_box_taunts=None,
minions_box_playable=None,
stage=None,
reduced_color=None,
):
logging.info("[ENTER] all_minion_data")
minion_coords = get_minions(src, minions_box)
# print minion_coords
# cull minion data not close to known minion coords to save time
culled_minion_data_boxes = []
for box in minion_data_boxes:
c_box = defines.c(box) # get a new reference so the defines list isn't permanently changed
for minion_coord in minion_coords:
if abs((c_box[0] + c_box[2]) / 2 - minion_coord[0]) <= 50:
culled_minion_data_boxes.append(box)
break
# print culled_minion_data_boxes
minion_data = get_minion_data_split(culled_minion_data_boxes, stage)
# print minion_data
if minions_box_taunts != None:
minion_taunts = get_taunt_minions(src, minions_box_taunts, min_threshold=20)
else:
minion_taunts = []
# print minion_taunts
if minions_box_taunts_reduced != None and reduced_color != None:
minion_taunts_reduced = color_range_reduced_mids(
src, minions_box_taunts_reduced, color=reduced_color, min_threshold=90, max_threshold=200
)
else:
minion_taunts_reduced = []
# print minion_taunts_reduced
minion_taunts.extend(minion_taunts_reduced)
if minions_box_playable != None:
minions_playable = color_range_reduced_mids(
src, minions_box_playable, color="green", min_threshold=45, max_threshold=200
)
else:
minions_playable = []
# print minions_playable
minions = []
minion_ad = 0
for coord in minion_coords:
minion = {}
minion["coord"] = coord
if len(minion_taunts):
min_coord = 9999
for t_coord in minion_taunts:
if abs(t_coord[0] - coord[0]) < min_coord:
min_coord = abs(t_coord[0] - coord[0])
if min_coord < 30:
minion["taunt"] = True
else:
minion["taunt"] = False
else:
minion["taunt"] = False
if len(minions_playable):
min_coord = 9999
for t_coord in minions_playable:
if abs(t_coord[0] - coord[0]) < min_coord:
min_coord = abs(t_coord[0] - coord[0])
if min_coord < 30:
minion["playable"] = True
else:
minion["playable"] = False
else:
minion["playable"] = False
minions.append(minion)
minion_ad += 1
if minion_data != None:
if len(minion_data) == 2 * len(minions):
if len(minion_data):
for i in range(0, len(minion_coords)):
minions[i]["attack"] = minion_data[2 * i]
minions[i]["defense"] = minion_data[2 * i + 1]
return minions
def player():
global src
global NEW_GAME, opponent_char, player_char, stage, current_decknum
logging.info("[ENTER] player")
control_success = True #keep track of whether or not the bot was able to control the mouse. If not the user is attempting to use it
actions.pause_pensively(1)
if NEW_GAME:
src = vision.screen_cap()
stage = vision.get_image_info_sift(src, stage_descs,
c(defines.stage_box))
NEW_GAME = False
#logging.info("------GET MATCH INFO------")
src = vision.screen_cap()
if player_char == None:
try:
player_char = vision.get_image_info_sift(src, character_descs,
c(defines.player_box))
except:
player_char = None
if stage == None:
try:
stage = vision.get_image_info_sift(src, stage_descs,
c(defines.stage_box))
except:
stage = None
#logging.info("---ATTACK WITH CHARACTER---")
actions.pause_pensively(0.25)
src = vision.screen_cap()
player_attack = vision.color_range_reduced_mids(
src, c(defines.reduced_player_box), color='green')
if player_attack and control_success:
control_success = actions.move_and_leftclick(c(defines.neutral_minion))
control_success = actions.move_and_leftclick(c(defines.player_hero))
#actions.move_cursor([player_attack[0][0],player_attack[0][1]+10])
actions.pause_pensively(0.1)
src = vision.screen_cap()
enemy = []
enemy.extend(
vision.color_range_reduced_mids(src,
c(defines.reduced_opponent_box1),
color='red'))
enemy.extend(
vision.color_range_reduced_mids(src,
c(defines.reduced_opponent_box2),
color='red'))
enemy_minions = vision.get_taunt_minions(
src, c(defines.enemy_minions_box_taunts))
if enemy_minions:
e_m = randint(0,
len(enemy_minions) -
1) #attack a random taunt minion
if enemy_minions:
control_success = actions.move_and_leftclick(enemy_minions[e_m])
elif enemy:
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
else:
#something's wrong, try to attack any minion
actions.pause_pensively(6)
enemy_minions = vision.color_range_reduced_mids(
src, c(defines.reduced_enemy_minions_box), color='red')
if enemy_minions:
control_success = actions.move_and_leftclick(enemy_minions[0])
control_success = actions.move_and_leftclick(c(defines.neutral))
#logging.info("------PLAY CARDS------")
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_cards_combo = vision.get_playable_cards(src,
c(defines.hand_box),
color='yellow')
if player_cards_combo and player_char == 'rogue': #active combo cards are played before non-combo cards
player_cards = player_cards_combo
while player_cards and control_success:
control_success = actions.move_and_leftclick(
player_cards[weighted_randint(len(player_cards))])
actions.move_cursor(c(defines.nuetral_targeting))
src = vision.screen_cap()
targeting = vision.color_range_reduced_mids(
src, c(defines.nuetral_targeting_box), color='red_targeting')
if targeting:
if defines.TARGETING[
current_decknum] == defines.Target.OPPONENT_HERO:
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
if defines.TARGETING[current_decknum] == defines.Target.OPPONENT_HERO:
actions.move_and_leftclick(
c(defines.play_card[randint(0,
len(defines.play_card) - 1)]))
actions.move_cursor(c(defines.nuetral_targeting))
src = vision.screen_cap()
targeting = vision.color_range_reduced_mids(
src, c(defines.nuetral_targeting_box), color='red_targeting')
if targeting:
if defines.TARGETING[
current_decknum] == defines.Target.OPPONENT_HERO:
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
control_success = actions.move_and_rightclick(c(
defines.neutral_minion))
actions.pause_pensively(1.5)
src = vision.screen_cap()
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_cards_combo = vision.get_playable_cards(src,
c(defines.hand_box),
color='yellow')
if player_cards_combo: #active combo cards are played before non-combo cards
player_cards = player_cards_combo
if not actions.check_game('Hearthstone'):
break
#logging.info("------PLAY ABILITY------")
actions.pause_pensively(0.50)
src = vision.screen_cap()
player_ability = vision.color_range_reduced_mids(
src, c(defines.reduced_ability_box), color='green')
if player_ability and player_char and control_success:
if player_char == 'mage':
control_success = actions.move_and_leftclick(
c(defines.player_ability))
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
elif player_char == 'priest':
control_success = actions.move_and_leftclick(
c(defines.player_ability))
control_success = actions.move_and_leftclick(c(
defines.player_hero))
else:
control_success = actions.move_and_leftclick(
c(defines.player_ability))
control_success = actions.move_and_leftclick(
c(defines.neutral_minion))
control_success = actions.move_and_rightclick(
c(defines.neutral_minion))
actions.pause_pensively(2)
player_ability = 0
#logging.info("---ATTACK WITH MINIONS---")
src = vision.screen_cap()
player_minions = vision.color_range_reduced_mids(
src,
c(defines.reduced_player_minions_box),
color='green',
min_threshold=45,
max_threshold=200)
while player_minions and control_success:
p_m = False
no_enemy_taunts_detected = True
min_subset = [False, 99]
src = vision.screen_cap()
enemy_minions = vision.get_taunt_minions(
src, c(defines.enemy_minions_box_taunts))
if enemy_minions:
no_enemy_taunts_detected = False
if defines.RANDOM_ATTACKS or defines.ref_game_screen_res_list[
defines.GAME_SCREEN_RES] == [1400, 1050]:
p_m = player_minions[randint(0,
len(player_minions) -
1)] #attack with a random minion
e_m = enemy_minions[randint(0,
len(enemy_minions) -
1)] #attack a random taunt minion
else:
if control_success:
player_minions_data = vision.all_minion_data(
src,
defines.player_minion_data_split,
defines.c(defines.player_minions_box),
minions_box_playable=defines.c(
defines.reduced_player_minions_box),
stage=stage)
enemy_minions_data = vision.all_minion_data(
src,
defines.enemy_minion_data_split,
defines.c(defines.enemy_minions_box),
minions_box_taunts_reduced=c(
defines.reduced_enemy_minions_box),
minions_box_taunts=defines.c(
defines.enemy_minions_box_taunts),
stage=stage,
reduced_color='red')
#print ''
#for i in range(0,len(enemy_minions_data)):
# print enemy_minions_data[i]
#print ""
#for i in range(0,len(player_minions_data)):
# print player_minions_data[i]
playable_minions = []
for player_minion in player_minions_data:
if player_minion['playable'] == True:
playable_minions.append(player_minion)
if playable_minions == []:
break
taunt_minions = []
for enemy_minion in enemy_minions_data:
if enemy_minion['taunt'] == True:
taunt_minions.append(enemy_minion)
subsets = []
for L in range(0, len(playable_minions) + 1):
for subset in combinations(playable_minions, L):
attack_total = 0
for individual in subset:
if 'attack' in individual:
if individual['attack'] != ' ':
attack_total += int(
individual['attack'])
if subset:
subsets.append([subset, attack_total])
min_subset = [False, 99]
#max_taunt = 0
min_difference = 99
for taunt_minion in taunt_minions:
#if taunt_minion['defense']>max_taunt[0]:
# max_taunt=taunt_minion['defense']
if 'defense' in taunt_minion:
if taunt_minion['defense'] == ' ':
taunt_minion['defense'] = '5'
else:
taunt_minion['defense'] = '5'
for subset in subsets:
difference = abs(subset[1] -
int(taunt_minion['defense']))
if subset[1] >= taunt_minion[
'defense'] and difference < min_difference and (
subset[1] < min_subset[1]
or len(subset) < len(min_subset)
): #attack_total > taunt defense
min_subset = subset
min_difference = difference
p_m = min_subset[0][0]['coord']
e_m = taunt_minion['coord']
if p_m == False:
p_m = player_minions[randint(
0,
len(player_minions) -
1)] #attack with a random minion
e_m = enemy_minions[randint(
0,
len(enemy_minions) -
1)] #attack a random taunt minion
#print 'Use subset: ',min_subset
else:
no_enemy_taunts_detected = True
if len(player_minions) > 1:
p_m = player_minions[randrange(0, len(player_minions) - 1)]
else:
p_m = player_minions[0]
control_success = actions.move_and_leftclick(p_m)
actions.move_cursor([
p_m[0], p_m[1] + int(150 * float(defines.game_screen_res[1]) /
float(defines.ref_game_screen_res[1]))
])
actions.pause_pensively(0.2)
src = vision.screen_cap()
enemy = []
enemy_freeze = None
enemy.extend(
vision.color_range_reduced_mids(src,
c(defines.reduced_opponent_box1),
color='red'))
enemy.extend(
vision.color_range_reduced_mids(src,
c(defines.reduced_opponent_box2),
color='red'))
enemy_freeze = vision.color_range_reduced_mids(
src, c(defines.reduced_opponent_box1), color='blue')
enemy_minions = vision.get_taunt_minions(
src, c(defines.enemy_minions_box_taunts))
if enemy_minions and no_enemy_taunts_detected: #something wrong has happened, try a bunch of stuff
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
actions.pause_pensively(2)
control_success = actions.move_and_leftclick(p_m)
actions.move_cursor([
p_m[0], p_m[1] + int(150 * float(defines.game_screen_res[1]) /
float(defines.ref_game_screen_res[1]))
])
actions.pause_pensively(0.2)
e_m = enemy_minions[randint(0,
len(enemy_minions) -
1)] #attack a random taunt minion
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_rightclick(
c(defines.neutral_minion))
actions.pause_pensively(2.5)
elif enemy_minions:
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
control_success = actions.move_and_rightclick(
c(defines.neutral_minion))
actions.pause_pensively(2.5)
elif enemy:
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
elif enemy_freeze:
control_success = actions.move_and_leftclick(
c(defines.opponent_hero))
else:
#something's wrong, try to attack any minion
actions.pause_pensively(6)
enemy_minions = vision.color_range_reduced_mids(
src, c(defines.reduced_enemy_minions_box), color='red')
if enemy_minions:
e_m = enemy_minions[randint(0,
len(enemy_minions) -
1)] #attack a random taunt minion
control_success = actions.move_and_leftclick(e_m)
control_success = actions.move_and_rightclick(
c(defines.neutral_minion))
actions.pause_pensively(2.5)
else:
actions.pause_pensively(6)
control_success = actions.move_and_rightclick(c(
defines.neutral_minion))
src = vision.screen_cap()
state_name = vision.get_state_sift(
src,
state_descs,
ignore_list=[
'versus.png', 'defeat.png', 'finding_opponent.png', 'gold.png',
'opponent_still_choosing.png', 'starting_hand.png', 'rank.png',
'victory.png'
])
if state_name == 'play':
break
if not actions.check_game('Hearthstone'):
break
player_minions = vision.color_range_reduced_mids(
src,
c(defines.reduced_player_minions_box),
color='green',
min_threshold=45,
max_threshold=200)
#logging.info("------PLAY INFO CHECK-------")
actions.pause_pensively(0.25)
src = vision.screen_cap()
state_name = vision.get_state_sift(src, state_descs)
player_cards = vision.get_playable_cards(src, c(defines.hand_box))
player_ability = vision.color_range_reduced_mids(
src, c(defines.reduced_ability_box), color='green')
if player_ability: #player ability still shows up even though we've past that section above, chances are the character is wrong
try:
player_char = vision.get_image_info_sift(src, character_descs,
c(defines.player_box))
except:
player_char = None
player_minions = vision.color_range_reduced_mids(
src,
c(defines.reduced_player_minions_box),
color='green',
min_threshold=45,
max_threshold=200)
player_attack = vision.color_range_reduced_mids(
src, c(defines.reduced_player_box), color='green')
if (
player_cards == [] and player_ability == []
and player_minions == [] and player_attack == []
) or player_cards == None or player_ability == None or player_minions == None or player_attack == None and control_success and (
state_name == defines.State.PLAYER
or state_name == defines.State.OPPONENT
or state_name == defines.State.PLAYER_GREEN):
#logging.info("---END TURN---")
control_success = actions.move_and_leftclick(c(defines.neutral))
player_turn_green_check = vision.color_range_reduced_mids(
src, c(defines.turn_box), color='green')
if player_turn_green_check != [] and player_turn_green_check != None and control_success:
control_success = actions.move_and_leftclick(c(
defines.turn_button))
control_success = actions.move_and_leftclick(c(defines.neutral))
else:
actions.pause_pensively(5)
player_end()
def all_minion_data(src,
minion_data_boxes,
minions_box,
minions_box_taunts_reduced=None,
minions_box_taunts=None,
minions_box_playable=None,
stage=None,
reduced_color=None):
logging.info("[ENTER] all_minion_data")
minion_coords = get_minions(src, minions_box)
#print minion_coords
#cull minion data not close to known minion coords to save time
culled_minion_data_boxes = []
for box in minion_data_boxes:
c_box = defines.c(
box
) #get a new reference so the defines list isn't permanently changed
for minion_coord in minion_coords:
if abs((c_box[0] + c_box[2]) / 2 - minion_coord[0]) <= 50:
culled_minion_data_boxes.append(box)
break
#print culled_minion_data_boxes
minion_data = get_minion_data_split(culled_minion_data_boxes, stage)
#print minion_data
if minions_box_taunts != None:
minion_taunts = get_taunt_minions(src,
minions_box_taunts,
min_threshold=20)
else:
minion_taunts = []
#print minion_taunts
if minions_box_taunts_reduced != None and reduced_color != None:
minion_taunts_reduced = color_range_reduced_mids(
src,
minions_box_taunts_reduced,
color=reduced_color,
min_threshold=90,
max_threshold=200)
else:
minion_taunts_reduced = []
#print minion_taunts_reduced
minion_taunts.extend(minion_taunts_reduced)
if minions_box_playable != None:
minions_playable = color_range_reduced_mids(src,
minions_box_playable,
color='green',
min_threshold=45,
max_threshold=200)
else:
minions_playable = []
#print minions_playable
minions = []
minion_ad = 0
for coord in minion_coords:
minion = {}
minion['coord'] = coord
if len(minion_taunts):
min_coord = 9999
for t_coord in minion_taunts:
if (abs(t_coord[0] - coord[0]) < min_coord):
min_coord = abs(t_coord[0] - coord[0])
if min_coord < 30:
minion['taunt'] = True
else:
minion['taunt'] = False
else:
minion['taunt'] = False
if len(minions_playable):
min_coord = 9999
for t_coord in minions_playable:
if (abs(t_coord[0] - coord[0]) < min_coord):
min_coord = abs(t_coord[0] - coord[0])
if min_coord < 30:
minion['playable'] = True
else:
minion['playable'] = False
else:
minion['playable'] = False
minions.append(minion)
minion_ad += 1
if minion_data != None:
if len(minion_data) == 2 * len(minions):
if len(minion_data):
for i in range(0, len(minion_coords)):
minions[i]['attack'] = minion_data[2 * i]
minions[i]['defense'] = minion_data[2 * i + 1]
return minions
