def __init__(self):
self.sm = SteemMonstersApi()
#self.api = SteemApi()
self.fm = FindMatch()
self.root = Tk()
self.flag = False
self.team_opponent = {}
with open('accounts.ini', 'r') as f:
raw = f.read()
self.fm.accounts_list = raw.replace('\n', ' ').split()
print('load accounts:', self.fm.accounts_list)
self.fm.nodes_list = storage.nodes
print('load nodes:', self.fm.nodes_list)
self.root.title('Explorer SteemMonsters')
self.root.minsize(700, 450)
self.root.maxsize(700, 450)
self.load_liga()
self.load_find_match()
self.load_vs()
self.load_unit()
self.sm.load_cards()
self.root.mainloop()
def __init__(self):
self.last_b = 30000000
self.sm = SteemMonstersApi()
self.api = Api()
self.load_state()
print('last block', self.state["last_block"])
def __init__(self, double = False, csv = False): self.last_b = 30000000 self.double = double self.csv = csv self.sm = SteemMonstersApi() self.api = Api() self.load_state()
def __init__(self):
self.sm_custom_cmd = {
'sm_find_match': self.sm_find_match,
'sm_submit_team': self.sm_submit_team,
'sm_team_reveal': self.sm_team_reveal,
}
self.liga_active = 'chemp'
self.sm_find_match_list = [] ### Кто подал заявку на батл
self.sm_battles_list = {} ### Список trx_id ожидающих и не только
self.sm_players_list = []
self.sm_vs_list = []
self.accounts_list = [] ### Список аккантов для отслеживания
self.replay = True
self.timestamp = '1983-03-26T12:12:12'
self.flag = True
self.sm = SteemMonstersApi()
class Deep():
decks = {} ### save load
### {team_csv, {"win": 0, "total": 0}}
### team_csv = ','.join([liga, ruleset, str(mana_cap), color, summoner] + monsters)
### summoner = level:name
files = {
"state_main": 'combo.json',
"state_bak": 'combo.bak',
"state_csv": 'combo.csv',
"state_csv_mini": 'combo_mini.csv',
}
types = [
'sm_battle', 'sm_start_quest', 'find_match', 'sm_submit_team',
'sm_team_reveal', 'token_transfer', 'sm_claim_reward',
'sm_combine_all', 'gift_packs', 'market_purchase', 'sm_combine_cards',
'open_pack', 'sm_sell_cards', 'sm_cancel_match', 'sm_surrender',
'sm_market_purchase', 'sm_gift_cards', 'guild_contribution',
'enter_tournament', 'sm_refresh_quest', 'sm_market_sale',
'purchase_orbs', 'delegate_cards', 'update_price', 'sm_cancel_sell',
'burn_cards', 'sm_card_award', 'sm_pack_purchase', 'undelegate_cards',
'join_guild', 'guild_accept', 'guild_promote', 'purchase_item'
]
def __init__(self):
self.last_b = 30000000
self.sm = SteemMonstersApi()
self.api = Api()
self.load_state()
print('last block', self.state["last_block"])
##### ##### ##### ##### #####
def load_state(self):
try:
with open(self.files["state_main"], 'r', encoding='utf8') as f:
self.state = json.load(f)
print('load state ok')
except:
# not exist or bad file, load copy in *.bak
try:
with open(self.files["state_bak"], 'r', encoding='utf8') as f:
self.state = json.load(f)
print('load state bak ok')
except:
self.state = {"last_block": self.last_b, "decks": {}}
self.save_state()
print('genesis new state')
def save_state(self):
self.decks = {}
print('save state')
with open(self.files["state_main"], 'w', encoding='utf8') as f:
json.dump(self.state, f, ensure_ascii=False)
with open(self.files["state_bak"], 'w', encoding='utf8') as f:
json.dump(self.state, f, ensure_ascii=False)
print('end save state')
print('save decks')
'''
with open(self.files["state_csv"], 'w') as f:
f.write(','.join(['Win', 'Total', 'Ruleset1', 'Ruleset2', 'Liga', 'Mana_cap', 'Color', 'Summoner']) + '\n')
for key, value in self.state["decks"].items():
f.write(','.join([str(value["win"]), str(value["total"]), key]) + '\n')
new_key = ';'.join([i.split(':')[0] for i in key.split(',')])
self.decks.setdefault(new_key, {"win": 0, "total": 0})
self.decks[new_key]["win"] += value["win"]
self.decks[new_key]["total"] += value["total"]
with open(self.files["state_csv_mini"], 'w') as f:
f.write(';'.join(['Win', 'Total', 'Ruleset1', 'Ruleset2', 'Liga', 'Mana_cap', 'Color', 'Summoner']) + '\n')
for key, value in self.decks.items():
f.write(';'.join([str(value["win"]), str(value["total"]), key]) + '\n')
'''
print('end save decks')
##### ##### ##### ##### #####
def upload(self):
block_end = self.api.get_irreversible_block()
print('update block_end', block_end)
n = 0
s = 0
while True:
ids = []
print('start from', self.state["last_block"], n, s)
data = self.sm.get_from_block(self.state["last_block"])
for line in data:
if line["type"] == 'sm_battle':
block_num = line["block_num"]
if line["error"] != None or line["success"] != True:
line.pop("data")
line.pop("result")
pprint(line)
input('next?')
else:
data = json.loads(line.pop("data"))
result = json.loads(line.pop("result"))
if result["match_type"] == 'Ranked':
mana_cap = result["mana_cap"]
# Новые правила двойных боев
ruleset = result["ruleset"].split(
'|') if '|' in result["ruleset"] else [
result["ruleset"], '-'
]
winner = result["winner"]
players = result["players"]
if result["id"] not in ids:
if players[0][
"initial_rating"] >= 100: # Отсеиваем новичков
#self.resolve_players(players)
if not result["details"].get("type", None):
for t in ["team1", "team2"]:
team = result["details"][t]
if team:
team_csv = self.sm.convert_team_to_csv(
team, ruleset, mana_cap)
if team_csv:
self.state[
"decks"].setdefault(
team_csv, {
"win": 0,
"total": 0
})
if winner == team[
'player']:
self.state["decks"][
team_csv][
"win"] += 1
self.state["decks"][
team_csv]["total"] += 1
ids.append(result["id"])
n += 1
self.state["last_block"] = line["block_num"] ###
s += 1
if s >= 1000:
self.save_state()
s = 0
if self.state["last_block"] > block_end:
self.save_state()
break
return
def resolve_players(self, players):
for player, oppenent in [[0, 1], [1, 0]]:
player_name = players[player]["name"]
oppenent_name = players[oppenent]["name"]
d = players[player]["initial_rating"] - players[player][
"final_rating"]
win, lose = [1, 0] if d > 0 else [0, 1]
self.state["players"].setdefault(player_name, {})
self.state["players"][player_name].setdefault(
oppenent_name, [0, 0])
self.state["players"][player_name][oppenent_name][0] += win
self.state["players"][player_name][oppenent_name][1] += lose
d_rating = players[player]["initial_rating"] - players[oppenent][
"initial_rating"]
if d_rating >= 0:
rating = str(int(d_rating / 5) * 5) # округление до шага 5
self.state["ratings"].setdefault(rating, [0, 0])
self.state["ratings"][rating][0] += win
self.state["ratings"][rating][1] += lose
return
class FindMatch():
step_part = 14 ### Количество выводимых строк
def __init__(self):
self.sm_custom_cmd = {
'sm_find_match': self.sm_find_match,
'sm_submit_team': self.sm_submit_team,
'sm_team_reveal': self.sm_team_reveal,
}
self.liga_active = 'chemp'
self.sm_find_match_list = [] ### Кто подал заявку на батл
self.sm_battles_list = {} ### Список trx_id ожидающих и не только
self.sm_players_list = []
self.sm_vs_list = []
self.accounts_list = [] ### Список аккантов для отслеживания
self.replay = True
self.timestamp = '1983-03-26T12:12:12'
self.flag = True
self.sm = SteemMonstersApi()
#self.api = SteemApi()
#self.sm.load_cards()
##### ##### #####
def run(self, liga):
#self.scan_blocks(self.resolve_block)
print('connect to', self.node)
self.api = SteemApi(nodes=[self.node])
self.liga_active = liga
self.flag = True
self.players = {
acc: {}
for acc in self.accounts_list
} ### Список своих аккаунтов для отслеживания {player:}
self.opponents = [] ### Список оппонентов, чтобы их подсвечивать
sm_thread = Thread(target=self.scan_blocks,
args=[self.resolve_block],
daemon=True)
sm_thread.start()
print('run scan')
def stop(self):
self.flag = False
self.sm_find_match_list = []
self.sm_battles_list = {}
self.sm_players_list = []
self.sm_vs_list = []
self.players = {acc: {} for acc in self.accounts_list}
self.replay = True
def scan_blocks(self, cmd):
print('reconnect')
last_block = self.api.get_head_block() - 1 * 20 #aka 1 min ###
print('replay... wait')
self.replay = True
while self.flag:
time_start = time()
head_block = self.api.get_head_block()
for b in range(last_block, head_block):
#print('next block', b)
cmd(self.api.get_block(b)) #resolve_block
###pprint(self.players)
self.check_battles()
time_end = time()
d = round(time_end - time_start)
tt = 3 - d
tt = 0 if tt < 0 else tt
last_block = head_block
#print('sleep', tt, 'sec')
self.replay = False
sleep(tt)
print('stop scan') ###
def resolve_block(self, block):
#self.timestamp = block["timestamp"].split('T')[1]
try:
self.timestamp = block["timestamp"]
except:
print('ERROR not correct block from b4')
sleep(3)
# check custom
for tx in block["transactions"]: ###
for op in tx["operations"]:
if op[0] == 'custom_json':
id = op[1].get('id')
if id in self.sm_custom_cmd:
player = op[1].get('required_posting_auths')[0]
#player = op[1].get('required_posting_auths', [None])[0]
data = json.loads(op[1].get('json', None))
trx_id = tx.get('transaction_id')
self.sm_custom_cmd[id](
player, data, trx_id,
self.timestamp) #sm_find_match and other
def sm_find_match(self, player, data, trx_id, timestamp):
if data["match_type"] == 'Ranked':
rating = self.sm.get_player_login(player)["rating"]
liga = self.sm.is_rating(rating)
if liga == self.liga_active:
hide = '' if self.sm.is_submit_hashed_team(player) else '*'
### Кто подал заявку на батл
self.sm_find_match_list.append({
"timestamp":
timestamp.split('T')[1],
"player":
player,
"liga":
liga,
"rating":
rating,
})
if len(self.sm_find_match_list) > self.step_part:
self.sm_find_match_list = self.sm_find_match_list[
-self.step_part:]
### Список trx_id ожидающих и не только
self.sm_battles_list[trx_id] = {
"player": player,
"rating": rating,
"timestamp": timestamp,
"hide": hide
}
#print('add trx', trx_id)
#print(timestamp, player, liga, rating)
def check_battles(self):
list_for_del = []
sm_players_list = []
for trx_id, value in self.sm_battles_list.items(): ### error
battle = self.sm.get_battle_status(trx_id)
if isinstance(battle, dict):
status = int(battle["status"])
if status == 0:
sm_players_list.append([
value["rating"], value["player"], value["timestamp"],
value["hide"]
])
elif status == 1:
#pprint(battle) ###
player = battle["player"]
opponent_player = battle["opponent_player"]
timestamp = str(battle["match_date"])
timestamp = timestamp.split('.')[0].split('T')[1]
mana_cap = battle["mana_cap"]
ruleset = battle["ruleset"]
inactive = battle["inactive"]
if player in self.players:
self.players[player][
"opponent_player"] = opponent_player
self.players[player][
"submit_hashed_team"] = self.sm.is_submit_hashed_team(
opponent_player)
if opponent_player not in self.opponents:
self.opponents.append(opponent_player)
opponent_colors = self.sm.get_opponent_colors(
opponent_player)
print(player, 'VS', opponent_player)
pprint(opponent_colors["procent"])
else:
self.sm_vs_list.append(
[timestamp, player, 'VS', opponent_player])
list_for_del.append(trx_id)
elif status == 2:
list_for_del.append(trx_id)
player = battle["player"]
opponent_player = battle["opponent_player"]
timestamp = str(battle["created_date"])
timestamp = timestamp.split('.')[0].split('T')[1]
if player in self.players:
print('round complete')
self.players[player] = {} # Обнуление
self.opponents.remove(opponent_player)
#pprint(battle)
self.sm_vs_list.append(
[timestamp, player, 'VS', opponent_player])
else:
list_for_del.append(trx_id)
player = battle["player"]
#pprint(battle)
if player in self.players:
print('round NOT complete')
self.players[player] = {}
if len(self.sm_vs_list) > self.step_part:
self.sm_vs_list = self.sm_vs_list[-self.step_part:]
for trx_id in list_for_del:
self.sm_battles_list.pop(trx_id)
self.sm_players_list = sm_players_list[:]
self.sm_players_list.sort(reverse=True)
def sm_submit_team(self, player, data, trx_id, timestamp):
for acc in self.players:
if player == self.players[acc].get("opponent_player", None):
try:
team = [data["summoner"]] + data["monsters"]
csv = self.sm.resolve_team(team, player)
print(self.timestamp, 'submit', player, csv)
except:
print(self.timestamp, 'hash team from', player)
csv = 'hash'
self.players[acc]["team"] = csv
def sm_team_reveal(self, player, data, trx_id, timestamp):
for acc in self.players:
if player == self.players[acc].get("opponent_player", None):
team = [data["summoner"]] + data["monsters"]
csv = self.sm.resolve_team(team, player)
print(self.timestamp, 'reveal', player, csv)
self.players[acc]["team"] = csv
class Deep():
decks = {} ### save load
### {team_csv, {"win": 0, "total": 0 and colors}}
### team_csv = ','.join([ruleset, liga, str(mana_cap), color, summoner] + monsters)
### summoner = level:name
files = {
"state_main": 'moon.json',
"state_bak": 'moon.bak',
"state_csv": 'moon.csv',
"state_csv_mini": 'moon_mini.csv',
}
types = ['sm_battle', 'sm_start_quest', 'find_match', 'sm_submit_team', 'sm_team_reveal', 'token_transfer', 'sm_claim_reward', 'sm_combine_all',
'gift_packs', 'market_purchase', 'sm_combine_cards', 'open_pack', 'sm_sell_cards', 'sm_cancel_match', 'sm_surrender',
'sm_market_purchase', 'sm_gift_cards', 'guild_contribution', 'enter_tournament', 'sm_refresh_quest', 'sm_market_sale',
'purchase_orbs', 'delegate_cards', 'update_price', 'sm_cancel_sell', 'burn_cards', 'sm_card_award', 'sm_pack_purchase',
'undelegate_cards', 'join_guild', 'guild_accept', 'guild_promote', 'purchase_item']
def __init__(self, double = False, csv = False):
self.last_b = 30000000
self.double = double
self.csv = csv
self.sm = SteemMonstersApi()
self.api = Api()
self.load_state()
##### ##### ##### ##### #####
def load_state(self):
try:
with open(self.files["state_main"], 'r', encoding = 'utf8') as f:
self.state = json.load(f)
print('load state ok')
except:
# not exist or bad file, load copy in *.bak
try:
with open(self.files["state_bak"], 'r', encoding = 'utf8') as f:
self.state = json.load(f)
print('load state bak ok')
except:
self.state = {"last_block": self.last_b, "decks": {liga: {} for liga in self.sm.ratings}}
self.save_state()
print('genesis new state')
def save_state(self):
self.decks = {}
print('save state')
with open(self.files["state_main"], 'w', encoding = 'utf8') as f:
json.dump(self.state, f, ensure_ascii = False)
if self.double:
with open(self.files["state_bak"], 'w', encoding = 'utf8') as f:
json.dump(self.state, f, ensure_ascii = False)
if self.csv:
with open(self.files["state_csv"], 'w', encoding = 'utf8') as f:
for liga, v1 in self.state["decks"].items():
for ruleset, v2 in v1.items():
for mana_cap, v3 in v2.items():
for team, v4 in v3.items():
players = []
for player, v5 in v4["player"].items():
p5 = ':'.join([player, str(v5["win"]), str(v5["lose"])])
players.append(p5)
p4 = ','.join(players)
p3 = ':'.join([str(v4[cmd]) for cmd in ["win", "total", "Red", "Blue", "Green", "White", "Black", "Gold"]])
line = ';'.join([p3, p4, liga, ruleset, mana_cap, team])
f.write(line + '\n')
print('end save state')
##### ##### ##### ##### #####
def load_moon(self, login):
collection = self.sm.get_player_collection(login)
self.moon_cards = {}
for uid, card in collection.items():
name, level = card["name"], card["level"]
self.moon_cards.setdefault(name, {"level": level, "uid": uid})
if level > self.moon_cards[name]["level"]:
self.moon_cards[name] = {"level": level, "uid": uid}
self.moon_decks = {liga: {} for liga in self.sm.ratings}
for liga, v1 in self.state["decks"].items():
for ruleset, v2 in v1.items():
for mana_cap, v3 in v2.items():
for team, v4 in v3.items():
color, *combo = team.split(';')
win, total = v4["win"], v4["total"]
for i in range(len(self.sm.colors) - 1):
opponent_color = self.sm.colors[i]
win_color = v4[opponent_color]
k_moon = round((win_color / total) * (win / total) * (win + total), 3)
self.moon_decks[liga].setdefault(ruleset, {})
self.moon_decks[liga][ruleset].setdefault(mana_cap, {})
self.moon_decks[liga][ruleset][mana_cap].setdefault(opponent_color, {})
self.moon_decks[liga][ruleset][mana_cap][opponent_color].setdefault(color, {"team": ['xxx'], "k_moon": -100, "best": combo, "k_best": k_moon})
if k_moon > self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["k_best"]:
self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["k_best"] = k_moon
self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["best"] = combo
flag = True
for card in combo:
name, level = card.split(':')
level = int(level)
if name in self.moon_cards:
for k in range(level - self.moon_cards[name]["level"]):
k_moon = round(k_moon * 0.75, 3)
else:
flag = False
break
if flag:
if k_moon > self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["k_moon"]:
self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["k_moon"] = k_moon
self.moon_decks[liga][ruleset][mana_cap][opponent_color][color]["team"] = combo
##### ##### ##### ##### #####
def upload(self):
block_end = self.api.get_irreversible_block()
print('update block_end:', block_end, 'last block:', self.state["last_block"])
n = 0
s = 0
while True:
ids = []
print('start from', self.state["last_block"], n, s, 'update block_end:', block_end)
data = self.sm.get_from_block(self.state["last_block"])
for line in data:
if line["type"] == 'sm_battle':
block_num = line["block_num"]
if line["error"] != None or line["success"] != True:
line.pop("data")
line.pop("result")
pprint(line)
input('next?')
else:
data = json.loads(line.pop("data"))
result = json.loads(line.pop("result"))
if result["match_type"] == 'Ranked':
mana_cap = str(result["mana_cap"])
ruleset = self.sm.check_ruleset(result["ruleset"])
winner = result["winner"]
players = result["players"]
if result["id"] not in ids:
liga = self.sm.is_rating(players[0]["initial_rating"])
if liga: # Отсеиваем новичков >= 100
if not result["details"].get("type", None):
for team_player, team_opponent in [["team1", "team2"], ["team2", "team1"] ]:
team = result["details"][team_player]
if team:
oppenent_color = result["details"][team_opponent]["color"]
team_csv = self.convert_team_to_csv(team)
if team_csv:
self.state["decks"][liga].setdefault(ruleset, {})
self.state["decks"][liga][ruleset].setdefault(mana_cap, {})
self.state["decks"][liga][ruleset][mana_cap].setdefault(team_csv, {
"win": 0, "total": 0,
"Red": 0, "Blue": 0, "Green": 0, "White": 0, "Black": 0, "Gold": 0,
"player": {}})
self.state["decks"][liga][ruleset][mana_cap][team_csv]["player"].setdefault(team["player"], {
"win": 0, "lose": 0})
if winner == team["player"]:
self.state["decks"][liga][ruleset][mana_cap][team_csv]["win"] += 1
self.state["decks"][liga][ruleset][mana_cap][team_csv][oppenent_color] += 1
self.state["decks"][liga][ruleset][mana_cap][team_csv]["player"][team['player']]["win"] += 1
else:
self.state["decks"][liga][ruleset][mana_cap][team_csv][oppenent_color] -= 1
self.state["decks"][liga][ruleset][mana_cap][team_csv]["player"][team['player']]["lose"] += 1
self.state["decks"][liga][ruleset][mana_cap][team_csv]["total"] += 1
ids.append(result["id"])
n += 1
self.state["last_block"] = line["block_num"] ###
s += 1
if s >= 1000:
self.save_state()
s = 0
if self.state["last_block"] > block_end:
self.save_state()
break
return
def convert_team_to_csv(self, team):
liga = self.sm.is_rating(team["rating"])
if liga:
try:
summoner = self.sm.card_names[team["summoner"]["card_detail_id"]] + ':' + str(team["summoner"]["level"])
monsters = [self.sm.card_names[monster["card_detail_id"]] + ':' + str(monster["level"]) for monster in team["monsters"]]
combo = self.sm.check_rarity([summoner] + monsters, liga)
color = self.sm.check_color(combo)
csv = ';'.join([color] + combo)
return(csv)
except:
pprint(team)
input('Error convert')
return False
class Explorer():
color_stop = 'red'
color_go = 'green'
color_opponent_hide = 'red'
color_opponent_not_hide = 'cyan'
scan_sleep = 0.5
sleep_team_opponent = 5
def __init__(self):
self.sm = SteemMonstersApi()
#self.api = SteemApi()
self.fm = FindMatch()
self.root = Tk()
self.flag = False
self.team_opponent = {}
with open('accounts.ini', 'r') as f:
raw = f.read()
self.fm.accounts_list = raw.replace('\n', ' ').split()
print('load accounts:', self.fm.accounts_list)
self.fm.nodes_list = storage.nodes
print('load nodes:', self.fm.nodes_list)
self.root.title('Explorer SteemMonsters')
self.root.minsize(700, 450)
self.root.maxsize(700, 450)
self.load_liga()
self.load_find_match()
self.load_vs()
self.load_unit()
self.sm.load_cards()
self.root.mainloop()
def scan(self):
while self.flag:
### find_match_label ###
#print(self.fm.sm_find_match_list)
raw_text = [' '.join([i["timestamp"], str(i["rating"]), i["player"]]) for i in self.fm.sm_find_match_list]
new_text = '\n'.join(raw_text)
self.find_match_label["text"] = new_text if not self.fm.replay else 'replay'
### vs_label ###
raw_text = [' '.join(i) for i in self.fm.sm_vs_list]
new_text = '\n'.join(raw_text)
self.vs_label["text"] = new_text if not self.fm.replay else 'replay'
### pool_label ###
now = int(mktime(strptime(self.fm.timestamp, time_format)))
raw_text = [' '.join(['{:>3}'.format(str(now - int(mktime(strptime(i[2], time_format))))), 'sec', str(i[0]), i[1], i[3]]) for i in self.fm.sm_players_list]
new_text = '\n'.join(raw_text)
self.pool_label["text"] = new_text if not self.fm.replay else 'replay'
self.pool_label["bg"] = self.color_stop if len(self.fm.sm_players_list) > 0 or self.fm.replay else self.color_go
### title ###
utc_unit = int(self.utc.get().replace('UTC', ''))
self.root.title(' '.join([str(int(time()) - now - utc_unit * 60 * 60), 'sec delta', 'Explorer SteemMonsters']))
### unit_opponent_label ###
player = self.unit.get()
#self.fm.players["player"] = player
opponent_player = self.fm.players[player].get("opponent_player", None)
if opponent_player:
self.unit_opponent_label["text"] = opponent_player
try:
bg = self.color_opponent_hide if self.fm.players[player]["submit_hashed_team"] else self.color_opponent_not_hide
except:
### point for error
bg = 'black'
##pprint(self.fm.players)
self.unit_opponent_label["bg"] = bg
else:
self.unit_opponent_label["text"] = ''
self.unit_opponent_label["bg"] = 'white'
### team_opponent ###
opponent_team = self.fm.players[player].get("team", None)
r = 25
x = 100
y = int(x * 420 / 300)
if opponent_team:
if opponent_team == 'hash':
hidden = 'HIDDEN'
for n in range(len(list(hidden))):
self.team_opponent[n] = { "image": Label(self.unit_opponent_frame),
"level": Label(self.unit_opponent_frame, text = hidden[n], font = 'Arial 40'),}
self.team_opponent[n]["image"].place(x = 0 + n * x, y = 0, width = x, height = y)
self.team_opponent[n]["level"].place(x = 0 + n * x, y = 0, width = x, height = y)
else:
for n in range(len(opponent_team)):
name, level = opponent_team[n].split(':')
self.team_opponent[n] = { "image": Label(self.unit_opponent_frame, image = self.sm.card_photos[name]),
"level": Label(self.unit_opponent_frame, text = level, font = 'Arial 18'),}
self.team_opponent[n]["image"].place(x = 0 + n * x, y = 0, width = x, height = y)
self.team_opponent[n]["level"].place(x = 50 - 0.5 * r + n * x, y = 140 - r - 5, width = 25, height = 25)
sleep(self.sleep_team_opponent)
# kill widgets
for n in range(len(self.team_opponent)):
self.team_opponent[n]["image"].destroy()
self.team_opponent[n]["level"].destroy()
self.team_opponent.pop(n)
#self.team_opponent = {}
#print('kill')
sleep(self.scan_sleep)
self.fm.stop()
##### ##### ##### ##### #####
def cmd_button_start(self):
self.fm.node = self.node.get()
self.button_start["state"] = DISABLED
self.button_stop["state"] = NORMAL
self.node_entry["state"] = DISABLED
for liga in self.liga_radiobuttons:
self.liga_radiobuttons[liga]["state"] = DISABLED
self.flag = True
sm_thread = Thread(target = self.scan, daemon = True)
sm_thread.start()
print(self.liga_var.get())
self.fm.run(self.liga_var.get())
def cmd_button_stop(self):
self.button_start["state"] = NORMAL
self.button_stop["state"] = DISABLED
self.node_entry["state"] = NORMAL
for liga in self.liga_radiobuttons:
self.liga_radiobuttons[liga]["state"] = NORMAL
print('end work')
self.flag = False
def load_liga(self):
self.liga_var = StringVar()
self.liga_var.set('chemp')
self.liga_radiobuttons = {}
menu_liga = [ ['Diamond+Champion', 'chemp'], ['Gold', 'gold'], ['Silver', 'silver'], ['Bronze', 'bronze'] ]
liga_frame = LabelFrame(self.root, width = 200, height = 250, text = 'Your League') #, bg = "green"
n = 0
for text, liga in menu_liga:
self.liga_radiobuttons[liga] = Radiobutton(liga_frame, text = text, variable = self.liga_var, value = liga)
self.liga_radiobuttons[liga].place(x = 0, y = n * 25)
n += 1
self.button_start = Button(liga_frame, text = 'Start', width = 10, command = self.cmd_button_start)
self.button_start.place(x = 5, y = 100)
self.button_stop = Button(liga_frame, text = 'Stop', width = 10, state = DISABLED, command = self.cmd_button_stop)
self.button_stop.place(x = 100, y = 100)
self.pool_label = Label(liga_frame, justify = LEFT, anchor = 'nw', bg = "red")
self.pool_label.place(x = 5, y = 130, width = 185, height = 95)
liga_frame.place(x = 0, y = 0)
def load_find_match(self):
find_match_frame = LabelFrame(self.root, width = 250, height = 250, text = 'Find Match') #
self.find_match_label = Label(find_match_frame, justify = LEFT, anchor = 'nw') #, bg = "green"
self.find_match_label.place(x = 5, y = 0, width = 235, height = 225)
find_match_frame.place(x = 200, y = 0)
def load_vs(self):
vs_frame = LabelFrame(self.root, width = 250, height = 250, text = 'Battles') #, bg = "green"
self.vs_label = Label(vs_frame, justify = LEFT, anchor = 'nw') #, bg = "green"
self.vs_label.place(x = 5, y = 0, width = 235, height = 225)
vs_frame.place(x = 450, y = 0)
def load_unit(self):
unit_frame = LabelFrame(self.root, width = 700, height = 200, text = 'Your VS Opponent') #, bg = "green"
#self.unit_entry = Entry(unit_frame, width = 200)
#self.unit_entry.place(x = 5, y = 0, width = 185, height = 25)
self.unit = StringVar(value = self.fm.accounts_list[0])
self.unit_entry = OptionMenu(unit_frame, self.unit, *self.fm.accounts_list)
self.unit_entry.place(x = 5, y = 0, width = 150, height = 25)
#self.unit_vs_label = Label(unit_frame, text = 'VS')
#self.unit_vs_label.place(x = 150, y = 0, width = 150, height = 25)
self.utc = StringVar(value = 'UTC+3')
utc_list = ['UTC' + str(n) for n in range(-12, 13)]
self.utc_optionmenu = OptionMenu(unit_frame, self.utc, *utc_list)
self.utc_optionmenu.place(x = 155, y = 0, width = 100, height = 25)
self.node = StringVar(value = self.fm.nodes_list[0])
self.node_entry = OptionMenu(unit_frame, self.node, *self.fm.nodes_list)
self.node_entry.place(x = 255, y = 0, width = 190, height = 25)
self.unit_opponent_label = Label(unit_frame, justify = LEFT, anchor = 'nw', bg = "white") #
self.unit_opponent_label.place(x = 455, y = 0, width = 235, height = 25)
self.unit_opponent_frame = Frame(unit_frame, width = 695, height = 145)
self.unit_opponent_frame.place(x = 0, y = 35)
unit_frame.place(x = 0, y = 250)