async def run():
auth = api.Auth("email", "password")
mainstring = "abcdefghijklmnopqrstuvwxyz"
secondstring = "abcdefghijklmnopqrstuvwxyz0123456789.-_"
for i in mainstring:
for j in secondstring:
for k in secondstring:
string = i + j + k
checkxbox = 0
checkpc = 0
checkpsn = 0
try:
await auth.get_player(string, api.Platforms.UPLAY)
checkpc = 1
except:
checkpc = 0
try:
await auth.get_player(string, api.Platforms.XBOX)
checkxbox = 1
except:
checkxbox = 0
try:
await auth.get_player(string, api.Platforms.PLAYSTATION)
checkpsn = 1
except:
checkpsn = 0
finally:
if (checkxbox == 0 and checkpsn == 0 and checkxbox == 0):
print(string)
async def stats():
playerList = []
proPlayers = []
# open text file and read each line into list
path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'R6ProPlayers.txt')
statFile = open(path)
for line in statFile:
playerList.append(line.replace('\n', ''))
# begin r6api byt opening with Ubisoft email and password, account is a throwaway account used for the project only
auth = api.Auth("*****@*****.**", "PythonProject")
# collect stats and initialize object with them
for name in playerList:
try:
player = await auth.get_player(name, api.Platforms.UPLAY)
await player.load_general()
kills = player.kills
deaths = player.deaths
assists = player.kill_assists
accuracy = (player.bullets_hit / player.bullets_fired)
revives = player.revives
winRate = (player.matches_won / player.matches_played)
proPlayers.append(R6Player(name, kills, deaths, assists, accuracy, revives, winRate))
except:
continue
# close api and return object list
await auth.close()
return proPlayers
async def run():
""" main function """
config_path = open("./config.json", 'r')
config = json.load(config_path)
client = MongoClient(config["mongodb addres"], config["mongodb port"])
recentdb = client['r6status']['recent']
olddb = client['r6status']['old']
userdb = client['r6status']['user']
id2uid = client['r6status']['id2uid']
live_id = client['r6status']['live_id']
dead_id = client['r6status']['dead_id']
mail = config["e-mail address"]
pswd = config["password"]
auth = r6sapi.Auth(mail, pswd)
try:
await auth.connect()
except r6sapi.exceptions.FailedToConnect as e:
print("type:{0}".format(type(e)))
print("args:{0}".format(e.args))
print("message:{0}".format(e.message))
print("{0}".format(e))
sys.exit(1)
lives = await dead_method(dead_id, auth)
players_data = await live_method(live_id, dead_id, auth, lives, userdb,
id2uid, recentdb)
olddb.insert_many(players_data)
await auth.close()
print(datetime.datetime.utcnow())
print("finised")
async def r6auth(self, email: str, password: str):
"""Give the bot an Ubisoft account login to request stats."""
self.settings["email"] = email
self.settings["password"] = password
self.auth = api.Auth(email=email, password=password)
dataIO.save_json(SETTINGS_PATH, self.settings)
await self.bot.say("Settings saved.")
def run():
auth = api.Auth("email", "password")
player = yield from auth.get_player("billy_yoyo", api.Platforms.UPLAY)
operator = yield from player.get_operator("sledge")
print(operator.kills)
yield from auth.close()
def __init__(self, bot: commands.Bot):
self.bot = bot
self.settings = dataIO.load_json(SETTINGS_PATH)
self.client = R6StatsClient("Red-DiscordBot-ToboCogs")
if "email" not in self.settings or "password" not in self.settings:
self.auth = None
else:
self.auth = api.Auth(self.settings["email"],
self.settings["password"])
async def run_first_row():
auth = api.Auth("email", "password")
firstrow = [""]
player = await auth.get_player("billy_yoyo", api.Platforms.UPLAY)
operators = await player.get_all_operators()
for o in operators:
firstrow.append(operators[o].name)
csvData.append(firstrow.copy())
await auth.close()
def run():
auth = api.Auth("*****@*****.**", "Chandra66")
usernames = ["assassin1901", "Pesto1911"]
for username in usernames:
player = yield from auth.get_player(username, api.Platforms.UPLAY)
operator = yield from player.load_general()
print(player.kills)
async def run():
global auth
auth = api.Auth(up_user, up_pword)
player_batch = await auth.get_player_batch(
names=[(username)], platform=api.Platforms.PLAYSTATION)
await run_general(player_batch)
await auth.close()
def run():
auth = api.Auth("email", "password")
usernames = ["billy_yoyo", "another_user"]
for username in usernames:
player = yield from auth.get_player(username, api.Platforms.UPLAY)
operator = yield from player.get_operator("sledge")
print("player %s has %s kills with sledge" %
(username, operator.kills))
def run():
auth = api.Auth("*****@*****.**", "password")
player = yield from auth.get_player("MrQW3RTY666", "uplay_test")
stats = yield from player.check_general()
print(
f"Matches played for MrQW3RTY666 on test servers (was 48): {player.matches_played}"
)
player = yield from auth.get_player("Griefdrums.", "uplay")
stats = yield from player.check_general()
print(
f"Matches played for Griefdrums. on test servers (was 998): {player.matches_played}"
)
yield from auth.session.close() #nicely close the session
async def run():
auth = r6sapi.Auth("email", "password")
player_batch = await auth.get_player_batch(
names=["player_1", "player_2", "player_3"],
platform=r6sapi.Platforms.UPLAY)
await run_rank(player_batch)
await run_ops(player_batch)
await run_weapons(player_batch)
await run_gamemodes(player_batch)
await run_general(player_batch)
await run_queues(player_batch)
await run_terrohunt(player_batch)
await auth.close()
async def stat(ctx, arg):
# TODO:add handler for null arg
auth = r6sapi.Auth(username, password)
player = await auth.get_player(arg, r6sapi.Platforms.UPLAY)
await r6sapi.Player.load_general(player)
await r6sapi.Player.load_queues(player)
n = len(opnamelist)
sorted_dict = {}
PTdict = {}
for i in range(n):
operator = await player.get_operator(opnamelist[i])
PTdict[operator.name] = operator.time_played
sorted_keys = sorted(PTdict, key=PTdict.get)
for w in sorted_keys:
sorted_dict[w] = PTdict[w]
j = len(sorted_keys)
combine = sorted_keys[j - 1] + ', ' + sorted_keys[
j - 2] + ', ' + sorted_keys[j - 3]
region = r6sapi.RankedRegions.NA
Rank = await player.get_rank(region)
rankstats = player.ranked
if rankstats.deaths == 0:
rankkd = 0
else:
rankkd = (round((rankstats.kills / rankstats.deaths), 2))
if player.deaths == 0:
kd = 0
else:
kd = (round((player.kills / player.deaths), 2))
mmr = Rank.mmr
rankurl = Rank.get_icon_url()
embed = discord.Embed(colour=discord.Colour(0xe75e15),
description="Here are the stats for %s" % arg)
staturlbase = "https://tabstats.com/siege/search/uplay/replace"
newurl = staturlbase.replace('replace', arg)
# embed here
embed.set_thumbnail(url=rankurl)
embed.set_author(name=arg, url=newurl)
embed.add_field(name="Overall K/D", value=kd)
embed.add_field(name="Ranked K/D", value=rankkd)
embed.add_field(name="Top Operators", value=combine)
embed.add_field(name="Current MMR", value=mmr)
await ctx.send(embed=embed)
await auth.close()
async def run(names, platform):
auth = api.Auth("email", "password")
print(names)
print(platform)
if platform == "x":
platform = api.Platforms.XBOX
if platform == "ps":
platform = api.Platforms.PLAYSTATION
if platform == "pc":
platform = api.Platforms.UPLAY
players = await auth.get_player_batch(names, platform)
await collectDat(players)
await auth.close()
async def r6(self, ctx, username):
r6auth = r6sapi.Auth(auth.r6username, auth.r6password)
try:
player = await r6auth.get_player(username, r6sapi.Platforms.UPLAY)
except:
await ctx.send("Player was not found.")
return
rank = await player.load_rank("ncsa")
await player.load_level()
await player.load_general()
await player.load_queues()
kdr = (player.kills) / (player.deaths)
kdar = (player.kills + player.kill_assists) / (player.deaths)
wlr = player.matches_won / player.matches_lost
swlr = rank.wins / rank.losses
embed = discord.Embed(title=username,
description="Level {}".format(player.level),
color=0xeee657)
embed.add_field(name="Player Profile", value=player.url, inline=False)
embed.add_field(name="Rank",
value="{}".format(rank.rank),
inline=False)
embed.add_field(name="MMR",
value="Current: {} Max: {}".format(
format(rank.mmr, '.2f'),
format(rank.max_mmr, '.2f')),
inline=False)
embed.add_field(name="Stats",
value="Kills: {} Assists: {} Deaths: {}".format(
player.kills, player.kill_assists, player.deaths),
inline=False)
embed.add_field(name="Lifetime Matches",
value="Won: {} Lost: {} WL: {}".format(
player.matches_won, player.matches_lost,
format(wlr, '.2f')),
inline=False)
embed.add_field(name="Seasonal Matches",
value="Won: {} Lost: {} WL: {}".format(
rank.wins, rank.losses, format(swlr, '.2f')),
inline=False)
embed.add_field(name="KD Ratio",
value="KD: {} KDA: {}".format(format(kdr, '.2f'),
format(kdar, '.2f')),
inline=False)
await ctx.send(embed=embed)
async def test():
auth = api.Auth('*****@*****.**', 'CiscoSquad14')
player = await auth.get_player('Crypto-Spartan', api.Platforms.UPLAY)
await player.check_level()
#for season_num in [-1, -2, -3]:
# await player.get_rank('NA', season=season_num)
await player.get_rank('NA', season=-2)
level = player.level
ranks = player.ranks
url = player.url
await auth.close()
print(url)
print(level)
print(ranks)
def run():
while True:
auth = api.Auth(username, password)
player = yield from auth.get_player(user, api.Platforms.UPLAY)
operators = input("Choose an Operator: ")
operator = yield from player.get_operator(operators)
KD = operator.kills / operator.deaths
WR = operator.wins / operator.losses
stringer = "You have %s kills and %s deaths on %s ... %s K/D Ratio" % (
operator.kills, operator.deaths, operators, KD)
wowsers = "You have %s wins and %s losses on %s ... %s Win Ratio" % (
operator.wins, operator.losses, operators, WR)
print(stringer)
print(wowsers)
grande = yield from player.load_general()
print(player.kills)
region = "NA"
ariana = yield from api.Rank(region)
print(ariana.mmr)
again = input("Another Operator? (Y/N)")
if again == "n":
break
async def run():
auth = api.Auth("email", "password")
firstrow = [""]
player = await auth.get_player("billy_yoyo", api.Platforms.UPLAY)
operators = await player.get_all_operators()
for o in operators:
firstrow.append(operators[o].name)
csvData.append(firstrow.copy())
#if(len(xboxnames) > 0):
# xbplayers = await auth.get_player_batch(xboxnames, api.Platforms.XBOX)
# await collectDat(xbplayers)
if(len(psnnames) > 0):
psplayers = await auth.get_player_batch(psnnames, api.Platforms.PLAYSTATION)
await collectDat(psplayers)
if(len(pcnames) > 0):
pcplayers = await auth.get_player_batch(pcnames, api.Platforms.UPLAY)
await collectDat(pcplayers)
await auth.close()
def get_userdata(playername):
auth = api.Auth(UPLAY_EMAIL, UPLAY_PASS)
def _get_userdata(p_name):
try:
player = yield from auth.get_player(p_name, api.Platforms.UPLAY)
except api.FailedToConnect:
print("FAILED TO CONNECT")
return -1
yield from player.check_queues()
yield from player.get_all_operators()
yield from player.get_rank("apac")
data = {"trophy": None, "casual": None, "rank": None}
data["trophy"] = player.ranks["apac:-1"].rank
data["casual"] = player.casual
data["rank"] = player.ranked
data["operator"] = top_operator(player.operators)
return data
return _get_userdata(playername)
def run():
auth = api.Auth(email, password)
file = open("new.txt", "w")
for username in usernames:
player = yield from auth.get_player(username, api.Platforms.UPLAY)
operator = yield from player.load_general()
kill = player.kills
death = player.deaths
win = player.matches_won
loss = player.matches_lost
file.write(str(kill) + ",")
file.write(str(death) + ",")
file.write(str(win) + ",")
file.write(str(loss) + ",")
file.close()
file = open("new.txt", "r")
lines = file.readlines()
file.close()
listing = []
for line in lines:
data = line.split(",")
for temp in data:
listing.append(temp)
print(listing)
file = open("old.txt", "r")
liners = file.readlines()
file.close()
lister = []
for line in liners:
data = line.split(",")
for temp in data:
lister.append(temp)
print(lister)
lister.pop()
listing.pop()
listing = [int(i) for i in listing]
lister = [int(i) for i in lister]
print(lister)
print(listing)
compared = []
count = 0
for b in lister:
value = listing[count] - b
count += 1
compared.append(value)
print(compared)
sorted = list(chunks(compared, 4))
print(sorted)
arrayOfKills = []
counter = 0
for i in sorted:
arrayOfKills.append(sorted[counter][0])
counter += 1
print(arrayOfKills)
bestKiller = max(arrayOfKills)
indexBestKiller = arrayOfKills.index(bestKiller)
print(indexBestKiller)
arrayOfDeaths = []
counter0 = 0
for i in sorted:
arrayOfDeaths.append(sorted[counter0][1])
counter0 += 1
bestDeath = max(arrayOfDeaths)
indexDeath = arrayOfDeaths.index(bestDeath)
print(indexDeath)
arrayOfWins = []
counter1 = 0
for i in sorted:
if sorted[counter1][3] == 0:
sorted[counter1][3] = 1
arrayOfWins.append(sorted[counter1][2] / sorted[counter1][3])
counter1 += 1
bestWinner = max(arrayOfWins)
indexWin = arrayOfWins.index(bestWinner)
print(indexWin)
arrayOfLosses = []
counter2 = 0
for i in sorted:
arrayOfLosses.append(sorted[counter2][3])
counter2 += 1
bestLoser = max(arrayOfLosses)
indexLoss = arrayOfLosses.index(bestLoser)
print(indexLoss)
arrayOfKDs = []
counter3 = 0
for i in usernames:
if sorted[counter3][1] == 0:
sorted[counter3][1] = 1
arrayOfKDs.append(sorted[counter3][0] / sorted[counter3][1])
counter3 += 1
arrayOfKillRate = []
counter4 = 0
for i in usernames:
counter += 1
temp = sorted[counter4][2] + sorted[counter4][3]
if temp == 0:
temp = 1
arrayOfKillRate.append(sorted[counter4][0] / temp)
file = open("printer.txt", "w")
ranger = len(arrayOfKDs)
ranger = ranger
for x in range(ranger):
comma = ","
needWrite = (str(usernames[x]) + comma)
needing = (str(arrayOfKills[x]) + comma)
needer = (str(arrayOfWins[x]) + comma)
needs = (str(arrayOfKillRate[x]) + comma)
needToWrite = (str(arrayOfKDs[x]) + comma)
file.write(needWrite)
file.write(needing)
file.write(needer)
file.write(needs)
file.write(needToWrite)
file.close()
print(arrayOfKDs)
print(usernames[indexBestKiller] + " is the best killer!")
print(usernames[indexDeath] + " dies a whole lot.")
print(usernames[indexWin] + " has won the most games.")
print(usernames[indexLoss] + " has lost the most games.")
def server_auth(self, email, password):
#self.auth = api.Auth(email, password)
self.auth = api.Auth(email.format(random.randint(1, 10)), password)
def get_Auth():
auth = api.Auth("*****@*****.**", "sinhoo5258")
return auth
def run(self):
self.get_credentials()
auth = api.Auth(self.username, self.password)
now = datetime.datetime.now()
date = now.strftime("%Y-%m-%d")
print(date)
weekday = now.weekday()
save = True
google_sheet = GoogleSheet()
general_sheet = google_sheet.get_sheet('general_stats')
player_sheet = google_sheet.get_sheet('players')
players = player_sheet.get_all_records()
for player in players:
username = player['Username']
name = player['Player']
# check activity by finding how many games were played before today
games_played = 0
try:
summary_sheet = google_sheet.get_sheet('summary')
player_row = summary_sheet.find(name).row
games_col = summary_sheet.find("Games").col
games_played = summary_sheet.col_values(games_col)
games_played = games_played[player_row - 1]
except Exception as e:
print('Could not find any games played!')
try:
games_played = int(games_played)
except ValueError:
games_played = 0
try:
player = yield from auth.get_player(username,
api.Platforms.UPLAY)
except api.r6sapi.InvalidRequest:
continue
general_stats = [name, date]
weapon_stats = [name, date]
operator_stats = [name, date]
gametype_stats = [name, date]
print(name, 'General Stats')
print('')
yield from player.check_level()
general_stats.append(player.level)
general_stats.append(player.xp)
print('Level:', player.level)
print('XP:', player.xp)
yield from player.check_general()
# if no matches have been played since last stat check, skip this player
if player.matches_played == games_played:
print('')
print('-----------------------------')
print('')
continue
general_stats.append(player.matches_played)
general_stats.append(player.matches_won)
general_stats.append(player.matches_lost)
general_stats.append(player.kills)
general_stats.append(player.deaths)
general_stats.append(str(round(player.time_played / 3600, 2)))
general_stats.append(player.melee_kills)
general_stats.append(player.kill_assists)
general_stats.append(player.penetration_kills)
general_stats.append(player.revives)
general_stats.append(player.bullets_fired)
general_stats.append(player.bullets_hit)
general_stats.append(player.headshots)
print('Played:', player.matches_played)
print('Wins:', player.matches_won)
print('Lost:', player.matches_lost)
print('Kills:', player.kills)
print('Deaths:', player.deaths)
print('Time Played:', round(player.time_played / 3600, 2), 'hours')
print('Melees:', player.melee_kills)
print('Assists:', player.kill_assists)
print('Penetrations:', player.penetration_kills)
print('Revives:', player.revives)
print('Bullets Fired:', player.bullets_fired)
print('Bullets Hit:', player.bullets_hit)
print('Headshots:', player.headshots)
print('')
yield from player.check_queues()
casual = player.casual
general_stats.append(casual.played)
general_stats.append(casual.won)
general_stats.append(casual.lost)
general_stats.append(casual.kills)
general_stats.append(casual.deaths)
general_stats.append(str(round(casual.time_played / 3600, 2)))
print(casual.name.title(), 'Stats')
print('Played:', casual.played)
print('Wins:', casual.won)
print('Lost:', casual.lost)
print('Kills:', casual.kills)
print('Deaths:', casual.deaths)
print('Time Played:', round(casual.time_played / 3600, 2), 'hours')
print('')
ranked = player.ranked
general_stats.append(ranked.played)
general_stats.append(ranked.won)
general_stats.append(ranked.lost)
general_stats.append(ranked.kills)
general_stats.append(ranked.deaths)
general_stats.append(str(round(ranked.time_played / 3600, 2)))
print(ranked.name.title(), 'Stats')
print('Played:', ranked.played)
print('Wins:', ranked.won)
print('Lost:', ranked.lost)
print('Kills:', ranked.kills)
print('Deaths:', ranked.deaths)
print('Time Played:', round(ranked.time_played / 3600, 2), 'hours')
print('')
region = api.RankedRegions.NA
season = yield from player.get_rank(region)
general_stats.append(season.season)
general_stats.append(str(int(season.mmr)))
general_stats.append(str(int(season.max_mmr)))
general_stats.append(str(round(season.skill_mean, 2)))
general_stats.append(str(round(season.skill_stdev, 2)))
print('Ranked Season Stats')
print('Current Season:', season.season)
print('Current MMR:', int(season.mmr))
print('Max MMR:', int(season.max_mmr))
print('Skill Mean:', round(season.skill_mean, 2))
print('Standard Deviation:', round(season.skill_stdev, 2))
print('')
print('-----------------------------')
print('')
if save:
general_sheet.append_row(general_stats)
if weekday == 6:
weapon_sheet = google_sheet.get_sheet('weapon_stats')
operator_sheet = google_sheet.get_sheet('operator_stats')
gametype_sheet = google_sheet.get_sheet('gametype_stats')
weapons = yield from player.check_weapons()
for w in weapons:
weapon_stats.append(w.kills)
weapon_stats.append(w.headshots)
weapon_stats.append(w.hits)
weapon_stats.append(w.shots)
print(w.name, 'Stats')
print('Kills:', w.kills)
print('Headshots:', w.headshots)
print('Hits:', w.hits)
print('Shots:', w.shots)
print('')
operators = []
attack_operators = [
'Ash', 'Blitz', 'Blackbeard', 'Buck', 'Capitao', 'Fuze',
'Glaz', 'Hibana', 'IQ', 'Jackal', 'Montagne', 'Sledge',
'Thatcher', 'Thermite', 'Twitch'
]
defense_operators = [
'Bandit', 'Castle', 'Caveira', 'Doc', 'Echo', 'Frost',
'Jager', 'Kapkan', 'Mira', 'Mute', 'Pulse', 'Rook',
'Smoke', 'Tachanka', 'Valkyrie'
]
new_operators = [
'Ying', 'Lesion', 'Zofia', 'Ela', 'Dokkaebi', 'Vigil',
'Lion', 'Finka', 'Maestro', 'Alibi'
]
operators.extend(attack_operators)
operators.extend(defense_operators)
operators.extend(new_operators)
for op_name in operators:
operator = yield from player.get_operator(op_name)
operator_stats.append(operator.kills)
operator_stats.append(operator.deaths)
operator_stats.append(operator.wins)
operator_stats.append(operator.losses)
operator_stats.append(operator.headshots)
operator_stats.append(operator.melees)
operator_stats.append(operator.dbnos)
operator_stats.append(
str(round(operator.time_played / 3600, 2)))
operator_stats.append(
str(operator.statistic) + ' ' +
operator.statistic_name)
print(op_name, 'Stats')
print('Kills:', operator.kills)
print('Deaths:', operator.deaths)
print('Wins:', operator.wins)
print('Losses:', operator.losses)
print('Headshots:', operator.headshots)
print('Melees:', operator.melees)
print('DBNOs:', operator.dbnos)
print('Time:', round(operator.time_played / 3600, 2),
'hours')
print('Statistic:', operator.statistic,
operator.statistic_name)
print('')
gametypes = yield from player.check_gamemodes()
for g in gametypes:
gtype = gametypes[g]
gametype_stats.append(gtype.played)
gametype_stats.append(gtype.won)
gametype_stats.append(gtype.lost)
gametype_stats.append(gtype.best_score)
print(gtype.name, 'Stats')
print('Played:', gtype.played)
print('Wins:', gtype.won)
print('Lost:', gtype.lost)
print('Best Score:', gtype.best_score)
print('')
if save:
weapon_sheet.append_row(weapon_stats)
operator_sheet.append_row(operator_stats)
gametype_sheet.append_row(gametype_stats)
time.sleep(5)
yield from auth.session.close()
def __init__(self, bot):
self.bot = bot
self._last_member = None
self.auth = r6.Auth(environ.get('ubi_email'), environ.get('ubi_pass'))
"mozzie": "https://marcopixel.eu/r6-operatoricons/icons/png/mozzie.png",
"lion":
"https://i.pinimg.com/originals/67/80/a9/6780a9553bc83816dfa92a947d73abec.gif",
"finka": "https://marcopixel.eu/r6-operatoricons/icons/png/finka.png",
"maverick":
"https://marcopixel.eu/r6-operatoricons/icons/png/maverick.png",
"nomad": "https://marcopixel.eu/r6-operatoricons/icons/png/nomad.png",
"gridlock": "https://marcopixel.eu/r6-operatoricons/icons/png/gridlock.png"
}
admin = [
"rush.your.b", "xi习包子近平", "b--------d33", "yuki_o325", "anime_dadaq",
"qo___________op"
]
auth = r6.Auth(os.getenv("R6-ACCOUNT", None), os.getenv("R6-PASSWORD", None))
bot = commands.Bot(command_prefix='d.')
bot.remove_command('help')
##機器人啟動完成
@bot.event
async def on_ready():
game = discord.Game("d.help")
await bot.change_presence(activity=game)
print('Logged in as')
print(bot.user.name)
print(bot.user.id)
print('------')
def run(name):
auth = api.Auth("*****@*****.**", "Chandra66")
player = yield from auth.get_player(name, api.Platforms.UPLAY)
A = yield from player.get_rank("apac", season=-1)
mmr = A.mmr
print(A.GameQueue)
