async def get_schedule_infotext():
utcnow = pytz.utc.localize(datetime.datetime.utcnow())
matches = await get_upcoming_and_current()
max_r1_len = 0
max_r2_len = 0
for match in matches:
max_r1_len = max(max_r1_len,
len(strutil.tickless(match.racer_1.display_name)))
max_r2_len = max(max_r2_len,
len(strutil.tickless(match.racer_2.display_name)))
schedule_text = '``` \nUpcoming matches: \n'
for match in matches:
if len(schedule_text) > 1800:
break
schedule_text += '{r1:>{w1}} v {r2:<{w2}} : '.format(
r1=strutil.tickless(match.racer_1.display_name),
w1=max_r1_len,
r2=strutil.tickless(match.racer_2.display_name),
w2=max_r2_len)
if match.suggested_time - utcnow < datetime.timedelta(minutes=0):
schedule_text += 'Right now!'
else:
schedule_text += timestr.str_full_24h(match.suggested_time)
schedule_text += '\n'
schedule_text += '```'
return schedule_text
async def cawmentator_alert(self, match: Match):
"""PM an alert to the match cawmentator, if any, that the match is soon to begin
Parameters
----------
match: Match
"""
# PM a cawmentator alert
cawmentator = await match.get_cawmentator()
if cawmentator is None or match.time_until_match is None:
return
alert_format_str = 'Reminder: You\'re scheduled to commentate **{racer_1}** - **{racer_2}**, ' \
'which is scheduled to begin in {minutes} minutes.\n\n'
alert_text = alert_format_str.format(
racer_1=match.racer_1.display_name,
racer_2=match.racer_2.display_name,
minutes=int((match.time_until_match.total_seconds() + 30) // 60))
racer_1_stats = await leaguestats.get_league_stats(
match.racer_1.user_id)
racer_2_stats = await leaguestats.get_league_stats(
match.racer_2.user_id)
racer_1_infotext = await leaguestats.get_big_infotext(
user=match.racer_1, stats=racer_1_stats)
racer_2_infotext = await leaguestats.get_big_infotext(
user=match.racer_2, stats=racer_2_stats)
alert_text += '```' + strutil.tickless(racer_1_infotext) + '\n```'
alert_text += '```' + strutil.tickless(racer_2_infotext) + '\n```'
await self._client.send_message(cawmentator.member, alert_text)
def leaderboard(self):
new_leaderboard = '``` \n' + strutil.tickless(self._leaderboard_header(self.current_race)) \
+ self.current_race.status_str + '\n'
new_leaderboard += 'Entrants:\n'
new_leaderboard += strutil.tickless(self.current_race.leaderboard_text)
new_leaderboard += '```'
return new_leaderboard
async def post_result(self, race: Race):
await self.client.send_message(
self.results_channel,
'Race begun at {0}:\n```\n{1}{2}\n```'.format(
race.start_datetime.strftime("%d %B %Y, UTC %H:%M"),
strutil.tickless(self._leaderboard_header(race)),
strutil.tickless(race.leaderboard_text)))
async def _cawmentator_alert(match: Match):
"""PM an alert to the match cawmentator, if any, that the match is soon to begin
Parameters
----------
match: Match
"""
# PM a cawmentator alert
cawmentator = await match.get_cawmentator()
if cawmentator is None or match.time_until_match is None:
return
alert_format_str = 'Reminder: You\'re scheduled to cawmentate **{racer_1}** - **{racer_2}**, ' \
'which is scheduled to begin {timestamp}.\n\n'
alert_text = alert_format_str.format(
racer_1=match.racer_1.display_name,
racer_2=match.racer_2.display_name,
timestamp=match.discord_rel_timestamp
)
league_tag = match.league_tag
try:
await LeagueMgr().get_league(league_tag=league_tag)
racer_1_stats = await leaguestats.get_league_stats(league_tag=league_tag, user_id=match.racer_1.user_id)
racer_2_stats = await leaguestats.get_league_stats(league_tag=league_tag, user_id=match.racer_2.user_id)
racer_1_infotext = await leaguestats.get_big_infotext(user=match.racer_1, stats=racer_1_stats)
racer_2_infotext = await leaguestats.get_big_infotext(user=match.racer_2, stats=racer_2_stats)
alert_text += '```' + strutil.tickless(racer_1_infotext) + '\n```'
alert_text += '```' + strutil.tickless(racer_2_infotext) + '\n```'
except necrobot.exception.LeagueDoesNotExist:
pass
await cawmentator.member.send(alert_text)
def infobox(self) -> str:
return '```\n' \
'{0}\n' \
'{1}```'\
.format(
strutil.tickless(self.infoname),
strutil.tickless(self.infotext)
)
async def _do_execute(self, cmd):
infotext = await leaguestats.get_fastest_times_league_infotext(20)
infobox = '```\nFastest wins:\n{0}```'.format(
strutil.tickless(infotext)
)
await self.client.send_message(cmd.channel, infobox)
async def _do_execute(self, cmd):
async with cmd.channel.typing():
amplified = True
# Parse arguments
args = cmd.args
try:
base_arg_pos = args.index('nodlc')
amplified = False
args.pop(base_arg_pos)
except ValueError:
pass
if len(cmd.args) != 1:
await cmd.channel.send(
'{0}: Wrong number of arguments for `.fastest`.'.format(
cmd.author.mention))
return
ndchar = NDChar.fromstr(args[0])
if ndchar is None:
await cmd.channel.send(
'{0}: Couldn\'t parse {1} as a character.'.format(
cmd.author.mention, args[0]))
return
infotext = await racestats.get_fastest_times_infotext(
ndchar, amplified, 20)
infobox = 'Fastest public all-zones {2} {0} times:\n```\n{1}```'.format(
ndchar.name, strutil.tickless(infotext),
'Amplified' if amplified else 'base-game')
await cmd.channel.send(infobox)
async def _do_execute(self, cmd):
await server.client.send_typing(cmd.channel)
# Parse arguments
args = cmd.args
if len(args) > 1:
await self.client.send_message(
cmd.channel,
'{0}: Error: wrong number of arguments for `.stats`.'.format(
cmd.author.mention))
return
if len(args) == 0:
user = await userlib.get_user(discord_id=int(cmd.author.id),
register=True)
else: # len(args) == 1
racer_name = args[0]
user = await userlib.get_user(any_name=racer_name)
if user is None:
await self.client.send_message(
cmd.channel,
'Could not find user "{0}".'.format(racer_name))
return
# Show stats
general_stats = await racestats.get_general_stats(user.user_id)
await self.client.send_message(
cmd.channel, '```\n{0}\'s stats (public races):\n{1}\n```'.format(
strutil.tickless(user.display_name), general_stats.infotext))
async def leaderboard_text(self, daily_number: int, display_seed=False):
"""The text (results) for the leaderboard"""
text = "``` \n"
text += self.leaderboard_header(daily_number) + '\n'
if display_seed:
for row in await dailydb.get_daily_seed(
daily_id=daily_number, daily_type=self.daily_type.value):
text += "Seed: {}\n".format(row[0])
break
no_entries = True
rank = int(0)
prior_result = '' # detect and handle ties
rank_to_display = int(1)
reverse_levelsort = dailytype.character(
daily_type=self.daily_type, daily_number=daily_number) == 'Aria'
daily_times = sorted(
await dailydb.get_daily_times(daily_id=daily_number,
daily_type=self.daily_type.value),
key=lambda x: level.level_sortval(int(x[1]),
reverse=reverse_levelsort),
reverse=True)
for row in daily_times:
name = strutil.tickless(row[0])
lv = row[1]
time = row[2]
if lv == level.LEVEL_FINISHED:
result_string = racetime.to_str(time)
elif lv == level.LEVEL_NOS:
continue
else:
result_string = level.to_str(lv)
if result_string == '':
result_string = "death"
else:
result_string = "death ({0})".format(result_string)
rank += 1
no_entries = False
# update the rank only if we've gotten a different result than the last entrant
if result_string != prior_result: # kinda hacky to use a string comparison here, but works
rank_to_display = rank
prior_result = result_string
text += '{0: >3}. {1: <24} {2}\n'.format(rank_to_display, name,
result_string)
if no_entries:
text += 'No entries yet.\n'
text += '```'
return text
async def _do_execute(self, cmd):
if len(cmd.args) == 0:
user = await userlib.get_user(discord_id=int(cmd.author.id), register=True)
else:
username = cmd.arg_string
user = await userlib.get_user(any_name=username)
if user is None:
await cmd.channel.send(
"Couldn't find the user `{0}`.".format(username)
)
return
stats = await leaguestats.get_league_stats(user.user_id)
infobox = '```\nStats: {username}\n{stats}\n```'\
.format(
username=strutil.tickless(user.display_name),
stats=strutil.tickless(stats.infotext)
)
await cmd.channel.send(infobox)
async def _do_execute(self, cmd):
await server.client.send_typing(cmd.channel)
try:
category = Category.fromstr(cmd.arg_string)
except necrobot.exception.ParseException as e:
await self.client.send_message(cmd.channel, e)
return
infotext = await racestats.get_most_races_infotext(category, 20)
infobox = 'Most public {0} races:\n```\n{1}```'.format(
category.name, strutil.tickless(infotext))
await self.client.send_message(cmd.channel, infobox)
async def _do_execute(self, cmd):
if len(cmd.args) == 0:
await cmd.channel.send('Please specify a league for `{}`.'.format(
self.mention))
return
if len(cmd.args) > 2:
await cmd.channel.send(
'Too many arguments for `{}`. (Please enclose user names with spaces in quotes.)'
.format(self.mention))
return
league_tag = cmd.args[0].lower()
try:
await LeagueMgr().get_league(league_tag=league_tag)
except necrobot.exception.LeagueDoesNotExist:
await cmd.channel.send(
'Error: Can\'t find the league `{}`.'.format(league_tag))
return
if len(cmd.args) == 1:
user = await userlib.get_user(discord_id=int(cmd.author.id),
register=True)
else:
username = cmd.args[1]
user = await userlib.get_user(any_name=username)
if user is None:
await cmd.channel.send(
"Couldn't find the user `{0}`.".format(username))
return
stats = await leaguestats.get_league_stats(league_tag, user.user_id)
infobox = '```\nStats: {username}\n{stats}\n```'\
.format(
username=strutil.tickless(user.display_name),
stats=strutil.tickless(stats.infotext)
)
await cmd.channel.send(infobox)
async def _do_execute(self, cmd):
if len(cmd.args) != 1:
await cmd.channel.send(
'{0}: Wrong number of arguments for `.mostraces`.'.format(
cmd.author.mention))
return
ndchar = NDChar.fromstr(cmd.args[0])
if ndchar is None:
await cmd.channel.send(
'{0}: Couldn\'t parse {1} as a character.'.format(
cmd.author.mention, cmd.args[0]))
return
infotext = await racestats.get_most_races_infotext(ndchar, 20)
infobox = 'Most public all-zones {0} races:\n```\n{1}```'.format(
ndchar.name, strutil.tickless(infotext))
await cmd.channel.send(infobox)
async def _do_execute(self, cmd):
if len(cmd.args) != 1:
await cmd.channel.send(
'Wrong number of arguments for `{}`. (Remember to specify the league.)'
.format(self.mention))
return
league_tag = cmd.args[0].lower()
try:
await LeagueMgr().get_league(league_tag=league_tag)
except necrobot.exception.LeagueDoesNotExist:
await cmd.channel.send(
'Error: Can\'t find the league `{}`.'.format(league_tag))
return
infotext = await leaguestats.get_fastest_times_league_infotext(
league_tag=league_tag, limit=20)
infobox = '```\nFastest wins:\n{0}```'.format(
strutil.tickless(infotext))
await cmd.channel.send(infobox)
async def _do_execute(self, cmd):
amplified = True
# Parse arguments
args = cmd.args
try:
base_arg_pos = args.index('nodlc')
amplified = False
args.pop(base_arg_pos)
except ValueError:
pass
if len(args) > 1:
await cmd.channel.send(
'{0}: Error: wrong number of arguments for `.stats`.'.format(
cmd.author.mention))
return
if len(args) == 0:
user = await userlib.get_user(discord_id=int(cmd.author.id),
register=True)
else: # len(args) == 1
racer_name = args[0]
user = await userlib.get_user(any_name=racer_name)
if user is None:
await cmd.channel.send(
'Could not find user "{0}".'.format(racer_name))
return
# Show stats
general_stats = await racestats.get_general_stats(user.user_id,
amplified=amplified)
await cmd.channel.send(
'```\n{0}\'s stats ({1}, public all-zones races):\n{2}\n```'.
format(strutil.tickless(user.display_name),
'Amplified' if amplified else 'Base game',
general_stats.infotext))
