def step(self, action):
"""
{"card": (action_card, card_prob),
"pos_x": (action_pos_x, pos_x_prob),
"pos_y": (action_pos_y, pos_y_prob)}, actor_hidden
:param action:
:return:
"""
choice_index = None
if action["card"][0] == 0:
logger.info("do nothing or skip step.")
else:
card = action["card"][0]
loc_x = (int(action["pos_x"][0] * self.width // 6 + self.width // 6 // 2) + self.offset_w) * 2
loc_y = (int(action["pos_y"][0] * self.height // 8 + self.height // 8 // 2) + self.offset_h) * 2
# loc_x = (int(self.x * self.width // 6 + self.width // 6 // 2) + self.offset_w) * 2
# loc_y = (int(self.y * self.height // 8 + self.height // 8 // 2) + self.offset_h) * 2
# self.x = (self.x + 1) % 6
# self.y = (self.y + 1) % 8
start_x = self.card_location[card][0]
start_y = self.card_location[card][1]
logger.info(
"locate card {} {} {} {} {} {}.".format(card, action["card_prob"][0], action["pos_x"][0],
action["pos_y"][0], loc_x, loc_y))
if self.real_time:
self.device.swipe([start_x, start_y, loc_x, loc_y])
choice_index = [0]
self.actions.append(action)
return choice_index
def __init__(self, proxy_set=None):
self.enable = True
self.init_valid_proxies = 1
self.test_thread_nums = 20
self.proxy_least = 3
self.invalid_limit = 200
self.ban_re = r''
self.ban_code = [
503,
]
self.download_timeout = 60
self.test_urls = [
('http://www.w3school.com.cn', '06004630'),
]
self.test_proxy_timeout = 5
self.proxy_set = proxy_set or {}
# for k, v in self._settings:
# setattr(self, k, self.proxy_set.get(k, v))
# 代理列表和当前的代理指针，couter_proxy用作该代理下载的网页数量
self.proxy = []
self.proxy_index = 0
self.proxies = {}
self.counter_proxy = {}
self.fetch_new_proxy()
if self.proxies:
self.test_proxies(self.proxies, wait=True)
logger.info('Use proxy : %s', self.proxy)
def get(url):
if scrapy_configs.configs('debug'):
logger.info(url)
req_list = [
grequests.request("GET",
url=url,
headers=scrapy_configs.configs('api_headers'),
timeout=10)
]
return grequests.imap(req_list, exception_handler=err_handler)
def post(url, item):
if scrapy_configs.configs('debug'):
# logger.info(api_url)
logger.info(json.dumps(item, ensure_ascii=False))
req_list = [
grequests.request("POST",
url=url,
data=json.dumps(item),
headers=scrapy_configs.configs('api_headers'),
timeout=10)
]
return grequests.imap(req_list, exception_handler=err_handler)
def fetch_new_proxy(self):
"""
获取新的代理，目前从三个网站抓取代理，每个网站开一个线程抓取代理。
"""
logger.info('Starting fetch new proxy.')
# urls = ['xici', 'ip3336', 'kxdaili']
urls = ['kxdaili']
threads = []
for url in urls:
t = ProxyFetch(self.proxies, url)
threads.append(t)
t.start()
for t in threads:
t.join()
def test_proxies(self, proxies):
from func_timeout import func_timeout, FunctionTimedOut
for proxy, valid in proxies.items():
check_proxy_res = False
try:
check_proxy_res = func_timeout(6,
self.check_proxy,
args=(proxy, ))
except FunctionTimedOut:
logger.info(
"func:check_proxy can't finished within 6 second,try next check"
)
except Exception as e:
logger.info(e)
# if self.check_proxy(proxy):
if check_proxy_res:
self.auto_proxy.proxies[proxy] = True
self.auto_proxy.append_proxy(proxy)
def get_soup(url):
req = urllib.request.Request(url)
req.add_header(
"User-Agent",
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 "
"Safari/537.36")
while True:
try:
resp = urllib.request.urlopen(req, timeout=10)
html_doc = resp.read()
break
except HTTPError:
return None
except ValueError:
logger.info(
"Fetch proxy from {} fail, will try later.".format(url))
time.sleep(120)
soup = BeautifulSoup(html_doc, features='lxml')
return soup
def fetch_proxy_from_xici(self):
logger.info('get proxies from: %s' % self.url)
proxies = {}
url = "http://www.xicidaili.com/nn/"
try:
for i in range(1, 4):
soup = get_soup(url + str(i))
trs = soup.find("table", attrs={
"id": "ip_list"
}).find_all("tr")
for j, tr in enumerate(trs):
if 0 == j:
continue
tds = tr.find_all('td')
ip = tds[1].text
port = tds[2].text
proxy = ''.join(['http://', ip, ':', port]).encode('utf-8')
proxies[proxy] = False
except Exception as e:
logger.error('Failed to fetch_proxy_from_xici. Exception[%s]', e)
return proxies
def test_proxies(self, proxies, wait=False):
"""
测试代理可通性。测试网址、特征码以及测试线程数均可设置。
"""
list_proxy = proxies.items()
threads = []
n = int(math.ceil(len(list_proxy) / self.test_thread_nums))
for i in range(self.test_thread_nums):
# 将待测试的代理平均分给测试线程
list_part = list(list_proxy)[i * n:(i + 1) * n]
part = {k: v for k, v in list_part}
t = ProxyValidate(self, part)
threads.append(t)
t.start()
try:
soup = func_timeout(60,
self.ensure_has_valid_proxy,
args=(wait, threads))
except FunctionTimedOut:
logger.info("func:there is no valid proxy,go next step")
except Exception as e:
logger.info(e)
def fetch_proxy_from_ip3336(self):
logger.info('get proxies from: %s' % self.url)
proxies = {}
url = 'http://www.ip3366.net/free/?stype=1&page='
try:
for i in range(1, 6):
soup = get_soup(url + str(i))
trs = soup.find("div", attrs={
"id": "list"
}).table.find_all("tr")
for j, tr in enumerate(trs):
if 0 == j:
continue
tds = tr.find_all("td")
ip = tds[0].string.strip().encode('utf-8')
port = tds[1].string.strip().encode('utf-8')
proxy = ''.join(
['http://', ip.decode(), ':',
port.decode()])
proxies[proxy] = False
except Exception as e:
logger.error('Failed to fetch_proxy_from_ip3336. Exception[%s]', e)
return proxies
def get_frame(self):
time_mill = time.time() * 1000
if time_mill - self.pre_time < 800:
return [None, 1]
else:
self.pre_time = time_mill
app = QApplication(sys.argv)
screens = app.screens()
if len(screens) == 0:
logger.info("screen :0")
return [None, -1]
window = screens[0].grabWindow(self.hwnd)
if win32gui.IsWindow(self.hwnd) == 1:
window_rect = win32gui.GetWindowRect(self.hwnd)
img = window.toImage()
img_np = self.convertQImageToMat(img)
self.update_locate(window_rect, img_np.shape)
img_np = img_np[-2 - 960:-2, 2:-2, 0:3].copy()
if img_np.shape[0] != 960:
raise Exception("错误的分辨率")
return [img_np, 1]
else:
return [None, -1]
def _action_on_hall(self, result):
if self.log:
logger.info(
"game in hall:" + str(result.index) + " grey:" + str(result.is_grey) + " spent:" + str(result.milli))
if self.game_start and self.game_finish:
self.game_start = False
self.game_finish = False
if not self.game_start:
self._init_game(int(str(int(time.time() * 100))[-9:]))
if self.mode == self.MODE["battle"] and result.index == 2:
if self.retry > 25 and self.retry % 10 == 0:
self.retry = 0
self.device.tap_button([344, 1246])
elif self.mode == self.MODE["friend_battle_host"] and result.index == 3:
if result.is_grey:
if self.retry > 0 and self.retry % 5 == 0:
self.retry = 0
# normal 548 544 548 944
self.device.tap_button([548, 544])
else:
if result.purple_loc[0] != 0:
if self.retry > 0 and self.retry % 5 == 0:
self.retry = 0
self.device.tap_button([result.purple_loc[0], result.purple_loc[1]])
elif self.mode == self.MODE["friend_battle_guest"] and result.index == 3:
if not result.is_grey:
if result.yellow_loc[0] != 0:
if self.retry > 0 and self.retry % 5 == 0:
self.retry = 0
self.device.tap_button([result.yellow_loc[0], result.yellow_loc[1]])
self.retry += 1
def _init_game(self, gameId):
logger.info("agent {} init: {}".format(self.agent_id, gameId))
self.game_start = True
self.game_finish = False
self.frame_count = 0
self.skip_step = 0
self.game_id = gameId
self.record.init_record(gameId)
self.game_env.init_game(gameId, self.agent_id)
self.pattern = None
self.imgs = []
self.rewards = []
self.actions = []
# 剩余圣水量 双倍圣水 即死
self.env_states = []
# 0 ~ 93 可用的card 92种card消耗圣水量
self.card_types = []
self.card_properties = []
self.pre_mine_crown = 0
self.pre_opp_crown = 0
self.memory_record.append(gameId)
def change_proxy(self):
"""
切换代理。
"""
while True:
self.proxy_index = (self.proxy_index + 1) % len(self.proxy)
proxy_valid = self.proxies[self.proxy[self.proxy_index]]
if proxy_valid:
break
if self.len_valid_proxy() == 0:
logger.info(
'Available proxies is none.Waiting for fetch new proxy.')
break
logger.info('Change proxy to %s', self.proxy[self.proxy_index])
logger.info('Available proxies[%s]: %s', self.len_valid_proxy(),
self.valid_proxies())
# 可用代理数量小于预设值则扩展代理
if self.len_valid_proxy() < self.proxy_least:
self.extend_proxy()
def fetch_proxy_from_kxdaili(self):
logger.info('get proxies from: %s' % self.url)
proxies = {}
url = 'http://www.kxdaili.com/dailiip/1/%d.html'
try:
from func_timeout import func_timeout, FunctionTimedOut
for i in range(1, 11):
soup = None
try:
# soup = get_soup(url % i)
soup = func_timeout(5, get_soup, args=(url % i, ))
except FunctionTimedOut:
logger.info(
"func:get_soup can't get proxy within 5 second,try next"
)
except Exception as e:
logger.info(e)
if soup is None:
continue
trs = soup.find("table", attrs={
"class": "active"
}).find_all("tr")
for j, tr in enumerate(trs):
if 0 == j:
continue
tds = tr.find_all("td")
ip = tds[0].string.strip().encode('utf-8')
port = tds[1].string.strip().encode('utf-8')
proxy = ''.join(
['http://', ip.decode(), ':',
port.decode()])
proxies[proxy] = False
except Exception as e:
logger.error('Failed to fetch_proxy_from_kxdaili. Exception[%s]',
e)
return proxies
def _action_on_running(self, result, img):
self.retry = 0
if not self.game_start:
return
if self.log:
logger.info(str(self.device_id) + " running:" + str(result.frame_index) + " " +
str(len(self.env_states)) + " elixir:" + str(result.remain_elixir)
+ " spent:" + str(result.milli))
logger.info("{:s}:{:f}:{}-{:s}:{:f}:{}-{:s}:{:f}:{}-{:s}:{:f}:{}".format(CARD_DICT[result.card_type[0]],
result.prob[0],
result.available[0],
CARD_DICT[result.card_type[1]],
result.prob[1],
result.available[1],
CARD_DICT[result.card_type[2]],
result.prob[2],
result.available[2],
CARD_DICT[result.card_type[3]],
result.prob[3],
result.available[3], ))
logger.info("hp:{:f}-{:f}-{:f}-{:f}-{:f}-{:f}".format(result.opp_hp[0],
result.opp_hp[1],
result.opp_hp[2],
result.mine_hp[0],
result.mine_hp[1],
result.mine_hp[2], ))
if result.frame_index == -1:
self.pattern = self._crop_battle_filed(img)
self.record.record_pattern(self.pattern)
if result.frame_index < 0:
return
self.skip_step = self.skip_step - 1 if self.skip_step > 0 else 0
reward = 0
reward += result.opp_hp[0] * 0.2
reward += result.opp_hp[1] * 0.1
reward += result.opp_hp[2] * 0.1
reward -= result.mine_hp[0] * 0.2
reward -= result.mine_hp[1] * 0.1
reward -= result.mine_hp[2] * 0.1
if result.opp_crown > self.pre_opp_crown:
reward -= 0.6
self.pre_opp_crown = result.opp_crown
if result.mine_crown > self.pre_mine_crown:
reward += 0.6
self.pre_mine_crown = result.mine_crown
self._append_reward(reward, result.frame_index)
env_state, card_type, card_property = parse_frame_state(result)
self.card_location = {card_type[0]: self.card_choices[0], card_type[1]: self.card_choices[1],
card_type[2]: self.card_choices[2], card_type[3]: self.card_choices[3]}
self.env_states.append(env_state)
self.card_types.append(card_type)
self.card_properties.append(card_property)
img_state = self._crop_battle_filed(img)
img_state = cv2.resize(img_state, (192, 256))
self.imgs.append(img_state)
img_diff = extract_attention(img_state, self.pattern)
return [img_diff, env_state, card_type, card_property]
def _update_reward(self, reward_value, index):
if self.log and reward_value != 0:
logger.info("update step {} reward {:f} ".format(index, reward_value) +
("++++++++++" if reward_value > 0 else "----------"))
self.rewards[index] += reward_value
def _append_reward(self, reward_value, index):
if self.log and reward_value != 0:
logger.info("append step {} reward {:f} ".format(index, reward_value) +
("++++++++++" if reward_value > 0 else "----------"))
self.rewards.append(reward_value)
def execute_cmd(cmd):
logger.info("execute cmd:{:s}".format(cmd))
os.system(cmd)
def tap(x, y):
logger.info("tap :{:d} {:d}".format(x, y))
