def _send_mail(self, mail_text: str, session: InboundMessageSession):
if len(mail_text) > self.MAIL_MAX_LEN:
session.reply('{} Your message is too burdensome! '
'Send a concise version instead. '
'({}/{})'.format(gen_roar(), len(mail_text),
self.MAIL_MAX_LEN))
return
try:
platform_name = session.get_platform_name()
username = '******'.format(session.message['username'],
session.message['user_id'] or '',
platform_name)
self._database.put_mail(username, mail_text,
session.message['channel'])
except SenderOutboxFullError:
session.reply('{} How embarrassing! Your outbox is full!'.format(
gen_roar()))
except MailbagFullError:
session.reply(
'{} Incredulous! My mailbag is full! Read one instead!'.format(
gen_roar()))
else:
session.reply('Tremendous! I will deliver this mail to the next '
'recipient without fail! {}'.format(gen_roar()))
def _praise_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if text:
formatted_text = '{} Praise {}!'.format(gen_roar(), text)
else:
formatted_text = '{} Praise it! Raise it!'.format(gen_roar())
self._try_say_or_reply_too_long(formatted_text, session)
def _praise_command(self, session):
text = session.match.group(1).strip()
if text:
formatted_text = '{} Praise {}!'.format(gen_roar(), text)
else:
formatted_text = '{} Praise it! Raise it!'.format(gen_roar())
self._try_say_or_reply_too_long(formatted_text, session)
def _xd_command(self, session):
num = random.randint(0, 2)
if num == 0:
formatted_text = "{} xD MingLee".format(gen_roar().lower().replace("!", "?"))
elif num == 1:
formatted_text = "{} xD MingLee".format(gen_roar())
else:
formatted_text = "xD MingLee"
session.say(formatted_text)
def _mail_command(self, session: InboundMessageSession):
if session.message["channel"] in self._mail_disabled_channels:
session.reply("{} My mail services cannot be used here.".format(gen_roar().replace("!", ".")))
return
mail_text = session.match.group(2).strip()
if mail_text:
if len(mail_text) > self.MAIL_MAX_LEN:
session.reply(
"{} Your message is too burdensome! "
"Send a concise version instead. "
"({}/{})".format(gen_roar(), len(mail_text), self.MAIL_MAX_LEN)
)
return
try:
self._database.put_mail(session.message["username"], mail_text)
except SenderOutboxFullError:
session.reply("{} How embarrassing! Your outbox is full!".format(gen_roar()))
except MailbagFullError:
session.reply("{} Incredulous! My mailbag is full! Read one instead!".format(gen_roar()))
else:
session.reply(
"Tremendous! I will deliver this mail to the next " "recipient without fail! {}".format(gen_roar())
)
else:
if _random.random() < 0.3:
mail_info = self._database.get_old_mail()
else:
if _random.random() < 0.7:
skip_username = session.message["username"]
else:
skip_username = None
mail_info = self._database.get_mail(skip_username=skip_username)
if not mail_info and _random.random() < 0.3:
mail_info = self._database.get_old_mail()
if not mail_info:
session.reply("{} Outlandish! There is no new mail! You should send some!".format(gen_roar()))
else:
session.reply(
"{roar} I am delivering mail! "
"Here it is, {date}, from {username}: {msg}".format(
roar=gen_roar(),
username=mail_info["username"].title(),
date=arrow.get(mail_info["timestamp"]).humanize(),
msg=mail_info["text"],
),
multiline=True,
)
def _xd_command(self, session):
num = random.randint(0, 2)
if num == 0:
formatted_text = '{} xD MingLee'.format(gen_roar().lower().replace(
'!', '?'))
elif num == 1:
formatted_text = '{} xD MingLee'.format(gen_roar())
else:
formatted_text = 'xD MingLee'
session.say(formatted_text)
def _generate_match_command(self, session: InboundMessageSession):
if not self._match_generator:
session.reply("{} Feature not available!".format(gen_roar()))
return
args = session.match.group(1).lower().split()
try:
session.reply("{} {}".format(gen_roar(), self._match_generator.get_match_string(args)))
except MatchError as error:
session.reply("{} An error generating a match: {}".format(gen_roar(), error))
except (ValueError, IndexError, TypeError):
_logger.exception("Generate match error")
session.reply("{} An error occurred when generating a match!".format(gen_roar()))
def _food_next_command(self, session):
updated_string = self._food_updated_string(self._food_next_updated)
if not self._food_next:
session.reply(
'{} I have no idea what\'s playing on twitch.tv/food next! :( {}'
.format(gen_roar(), updated_string)
)
else:
title = self._food_next
if title == "voting":
message = "twitch.tv/food chat is currently voting for what to play next."
else:
message = 'twitch.tv/food will play "{}" next!'.format(title)
session.reply('{} {} {}'.format(gen_roar(), message, updated_string))
def _hype_stats_command(self, session: InboundMessageSession):
stats_filename = self._config.get('hype_stats_filename')
if not stats_filename or \
stats_filename and not os.path.exists(stats_filename):
session.reply('{} This command is currently unavailable!'.format(
gen_roar()))
return
try:
with open(stats_filename) as file:
doc = json.load(file)
text_1 = '[{duration}] Lines/sec {averages_str} ' \
'· Hints/sec {hint_averages_str}'.format(
duration=doc['stats']['duration'],
averages_str=doc['stats']['averages_str'],
hint_averages_str=doc['stats']['hint_averages_str'],
)
text_2 = 'Chat {chat_graph} · Hint {hint_graph}'.format(
chat_graph=doc['stats']['chat_graph'],
hint_graph=doc['stats']['hint_graph'],
)
except (ValueError, KeyError, IndexError):
_logger.exception('Error formatting stats')
else:
session.say(text_1)
session.say(text_2)
def _password_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if not text:
text = 'Groudonger'
if not self._password_api_limiter.is_ok('password'):
time.sleep(2)
self._password_api_limiter.update('password')
hasher = hashlib.sha1()
hasher.update(text.encode('utf8', 'replace'))
digest = hasher.hexdigest().lower()
result = 'Unable to check password.'
try:
response = requests.get(
'https://api.pwnedpasswords.com/range/{}'.format(digest[:5]),
headers={'user-agent': 'chatbot383'})
if response.status_code == 200:
if digest[5:] in response.text.lower():
result = '{} **is** a Pwned Password!'.format(text)
else:
result = '{} is not a Pwned Password'.format(text)
except requests.exceptions.RequestException:
_logger.exception('Password check error')
formatted_text = '{} {}'.format(gen_roar(), result)
self._try_say_or_reply_too_long(formatted_text, session)
def _debug_echo_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
formatted_text = '{} {} {}'.format(
gen_roar(), self._censor_text(session, text),
self._censor_text(session, text, extra_censor=True))
session.reply(formatted_text, escape_links=True)
def _hype_stats_command(self, session):
stats_filename = self._config.get('hype_stats_filename')
if not stats_filename or \
stats_filename and not os.path.exists(stats_filename):
session.reply(
'{} This command is currently unavailable!'.format(gen_roar()))
return
try:
with open(stats_filename) as file:
doc = json.load(file)
text_1 = '[{duration}] Lines/sec {averages_str} ' \
'· Hints/sec {hint_averages_str}'.format(
duration=doc['stats']['duration'],
averages_str=doc['stats']['averages_str'],
hint_averages_str=doc['stats']['hint_averages_str'],
)
text_2 = 'Chat {chat_graph} · Hint {hint_graph}'.format(
chat_graph=doc['stats']['chat_graph'],
hint_graph=doc['stats']['hint_graph'],
)
except (ValueError, KeyError, IndexError):
_logger.exception('Error formatting stats')
else:
session.say(text_1)
session.say(text_2)
def _try_say_or_reply_too_long(cls, formatted_text, session):
if cls.is_too_long(formatted_text):
session.reply(cls.TOO_LONG_TEXT_TEMPLATE.format(gen_roar()))
return False
else:
session.say(formatted_text)
return True
def _try_say_or_reply_too_long(cls, formatted_text, session):
if cls.is_too_long(formatted_text):
session.reply(cls.TOO_LONG_TEXT_TEMPLATE.format(gen_roar()))
return False
else:
session.say(formatted_text)
return True
async def _move_voice_command(self, message: discord.Message):
match = re.match(r'(?i)!movevoice(?:\s|$)(.*)', message.content)
if not match:
return False
channel_id = match.group(1).strip()
if not channel_id:
await message.channel.send('\n'.join(
'Channel ID {id_str} - <#{id_str}>'.format(id_str=id_str)
for id_str in self._config['voice_channel_whitelist']))
return True
elif channel_id not in self._config['voice_channel_whitelist']:
await message.channel.send(
"{} Unrecognized voice channel ID".format(gen_roar()))
return True
self._current_voice_channel = voice_channel = \
self._client.get_channel(channel_id)
if self._voice_client:
_logger.info('Moving voice to %s', voice_channel)
await self._voice_client.move_to(voice_channel)
return True
def _shuffle_command(self, session: InboundMessageSession):
word_shuffle = bool(session.match.group(1))
text = session.match.group(2).strip()
last_message = self._last_message.get(session.message['channel'])
if not text and last_message:
text = last_message['text']
elif not text:
text = 'Groudonger'
if word_shuffle:
shuffle_list = text.split()
sep = ' '
else:
shuffle_list = list(text)
sep = ''
_random.shuffle(shuffle_list)
shuffle_text = sep.join(shuffle_list).strip()
formatted_text = '{} Shuffled! {}'.format(gen_roar(), shuffle_text)
if self._config.get('ignore_slimo', False) and \
('chatotdungeon' in session.message['channel'] or
'electricnet' in session.message['channel']) and \
session.message['username'].startswith('slimoleq'):
pass
else:
self._try_say_or_reply_too_long(formatted_text, session)
def _food_current_command(self, session):
updated_string = self._food_updated_string(self._food_current_updated)
if not self._food_current:
session.reply(
'{} I have no idea what\'s playing on twitch.tv/food right now! :( {}'
.format(gen_roar(), updated_string)
)
else:
session.reply(
'{roar} twitch.tv/food is now playing "{title}"! {updated}'
.format(
roar=gen_roar(),
title=self._food_current,
updated=updated_string
)
)
def _room_size_command(self, session: InboundMessageSession):
formatted_text = \
'{} {} users in chat room.'.format(
gen_roar(), len(self._user_list[session.message['channel']])
)
self._try_say_or_reply_too_long(formatted_text, session)
def _countdown_command(self, session: InboundMessageSession):
try:
with open(self._config['event_data_file']) as file:
doc = json.load(file)
texts = []
for event_doc in doc['events']:
event_name = event_doc['name']
date_now = arrow.get()
date_event = arrow.get(event_doc['date'])
time_delta = date_event - date_now
if time_delta.total_seconds() >= 0:
phrase_ago = 'starts in'
else:
time_delta = abs(time_delta)
phrase_ago = 'started ago'
months, days = divmod(time_delta.days, 30)
minutes, seconds = divmod(time_delta.seconds, 60)
hours, minutes = divmod(minutes, 60)
texts.append('{} {} '
'{} {} {} {} {} {} {} {} {} {}'.format(
event_name,
phrase_ago,
months,
gettext.ngettext('month', 'months', months),
days,
gettext.ngettext('day', 'days', days),
hours,
gettext.ngettext('hour', 'hours', hours),
minutes,
gettext.ngettext('minute', 'minutes',
minutes),
seconds,
gettext.ngettext('second', 'seconds',
seconds),
))
formatted_text = '{} {}'.format(gen_roar(), ' • '.join(texts))
except (OSError, LookupError, ValueError, TypeError):
_logger.exception('No schedule')
formatted_text = '{} Schedule not available'.format(gen_roar())
self._try_say_or_reply_too_long(formatted_text, session)
def _rip_command(self, session: InboundMessageSession):
text = session.match.group(1).strip() or session.message["nick"]
formatted_text = "{} {}, {}. Press F to pay your respects.".format(
gen_roar(), _random.choice(("RIP", "Rest in peace")), text
)
self._try_say_or_reply_too_long(formatted_text, session)
def _generate_match_command(self, session: InboundMessageSession):
if not self._match_generator:
session.reply('{} Feature not available!'.format(gen_roar()))
return
args = session.match.group(1).lower().split()
try:
session.reply('{} {}'.format(
gen_roar(), self._match_generator.get_match_string(args)))
except MatchError as error:
session.reply('{} An error generating a match: {}'.format(
gen_roar(), error))
except (ValueError, IndexError, TypeError):
_logger.exception('Generate match error')
session.reply(
'{} An error occurred when generating a match!'.format(
gen_roar()))
def _schedule_command(self, session: InboundMessageSession):
try:
with open(self._config['event_data_file']) as file:
doc = json.load(file)
texts = []
for event_doc in doc['events']:
texts.append('{} {}'.format(event_doc['name'],
event_doc['schedule']))
formatted_text = '{} {}'.format(gen_roar(), ' • '.join(texts))
except (OSError, LookupError, ValueError, TypeError):
_logger.exception('No schedule')
formatted_text = '{} Schedule not available'.format(gen_roar())
self._try_say_or_reply_too_long(formatted_text, session)
def _rip_command(self, session):
text = session.match.group(1).strip() or session.message['nick']
formatted_text = \
'{} {}, {}. Press F to pay your respects.'.format(
gen_roar(), random.choice(('RIP', 'Rest in peace')), text
)
self._try_say_or_reply_too_long(formatted_text, session)
def _release_command(self, session: InboundMessageSession):
text = session.match.group(1).strip() or session.message['nick']
formatted_text = \
'{roar} {text} was released. Farewell, {text}!'.format(
roar=gen_roar(), text=text
)
self._try_say_or_reply_too_long(formatted_text, session)
def _greeting_command(self, session: InboundMessageSession):
is_set = session.match.group(1)
text = session.match.group(3).strip()
if is_set:
self._database.set_greeting(
session.message['channel'], session.message['user_id']
or session.message['username'], text)
session.reply('{} Greeting saved'.format(gen_roar()))
else:
greeting = self._database.get_greeting(session.message['channel'])
if greeting:
formatted_text = '{} {}'.format(gen_roar(), greeting)
else:
formatted_text = '{}'.format(gen_roar())
session.say(formatted_text, multiline=True)
def _rip_command(self, session: InboundMessageSession):
text = session.match.group(1).strip() or session.message['nick']
formatted_text = \
'{} {}, {}. Press F to pay your respects.'.format(
gen_roar(), _random.choice(('RIP', 'Rest in peace')), text
)
self._try_say_or_reply_too_long(formatted_text, session)
def _release_command(self, session):
text = session.match.group(1).strip() or session.message['nick']
formatted_text = \
'{roar} {text} was released. Farewell, {text}!'.format(
roar=gen_roar(), text=text
)
self._try_say_or_reply_too_long(formatted_text, session)
def _mail_status_command(self, session: InboundMessageSession):
unread_count = self._database.get_status_count("unread")
read_count = self._database.get_status_count("read")
session.reply(
"{roar} {unread} unread, {read} read, {total} total!".format(
roar=gen_roar(), unread=unread_count, read=read_count, total=unread_count + read_count
)
)
def _start_battle(self, opponent_username: str):
opponent_username = opponent_username.lower()
_logger.info('Start battle with %s', opponent_username)
self._battle_session = BattleSession(opponent_username, self._get_type_efficacy_table())
self._bot.send_text(BATTLEBOT_CHANNEL, gen_roar())
self._bot.send_whisper(BATTLEBOT_USERNAME, '!accept', allow_command_prefix=True)
def _mail_command(self, session):
mail_text = session.match.group(2).strip()
if mail_text:
if len(mail_text) > 200:
session.reply('{} Your message is too burdensome! '
'Send a concise version instead.'
.format(gen_roar()))
return
try:
self._database.put_mail(session.message['username'], mail_text)
except MailbagFullError:
session.reply(
'{} Incredulous! My mailbag is full! Read one instead!'
.format(gen_roar()))
else:
session.reply(
'Tremendous! I will deliver this mail to the next '
'recipient without fail! {}'.format(gen_roar()))
else:
if random.random() < 0.3:
mail_info = self._database.get_old_mail()
else:
mail_info = self._database.get_mail()
if not mail_info and random.random() < 0.3:
mail_info = self._database.get_old_mail()
if not mail_info:
session.reply(
'{} Outlandish! There is no mail! You should send some!'
.format(gen_roar())
)
else:
session.reply(
'{roar} I am delivering mail! '
'Here it is, {date}, from {username}: {msg}'
.format(
roar=gen_roar(),
username=mail_info['username'],
date=arrow.get(mail_info['timestamp']).humanize(),
msg=mail_info['text'])
)
def _xd_rand_command(self, session):
if _random.random() < 0.1 or \
session.message['username'] == 'wow_deku_onehand' and \
session.message['text'].strip() == 'xD MingLee':
def rep_func(match):
return '!' if _random.random() < 0.6 else '1'
session.say('{} xD MingLee'.format(
re.sub('!', rep_func, gen_roar().lower()))
)
def _wow_command(self, session: InboundMessageSession):
if self._tellnext_generator:
platform_name = session.get_platform_name()
max_len = 500 if platform_name == 'discord' else 400
session.say('> {}'.format(
self._censor_text(
session, self._tellnext_generator.get_paragraph(max_len))),
multiline=True)
else:
session.reply('{} Feature not available!'.format(gen_roar()))
def _double_command(self, session):
text = session.match.group(2).strip()
if not text:
text = 'ヽ༼ຈل͜ຈ༽ﾉ DOUBLE TEAM ヽ༼ຈل͜ຈ༽ﾉ'
double_text = ''.join(char * 2 for char in text)
formatted_text = '{} Doubled! {}'.format(gen_roar(), double_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _mail_status_command(self, session: InboundMessageSession):
unread_count = self._database.get_status_count('unread')
read_count = self._database.get_status_count('read')
session.reply(
'{roar} {unread} unread, {read} read, {total} total!'.format(
roar=gen_roar(),
unread=unread_count,
read=read_count,
total=unread_count + read_count))
def _mail_command(self, session: InboundMessageSession):
if session.message['channel'] in self._mail_disabled_channels:
session.reply('{} My mail services cannot be used here.'.format(
gen_roar().replace('!', '.')))
return
mail_text = session.match.group(2).strip()
if mail_text:
if len(mail_text) > self.MAIL_MAX_LEN:
session.reply('{} Your message is too burdensome! '
'Send a concise version instead. '
'({}/{})'.format(gen_roar(), len(mail_text),
self.MAIL_MAX_LEN))
return
try:
self._database.put_mail(session.message['username'], mail_text)
except SenderOutboxFullError:
session.reply(
'{} How embarrassing! Your outbox is full!'.format(
gen_roar()))
except MailbagFullError:
session.reply(
'{} Incredulous! My mailbag is full! Read one instead!'.
format(gen_roar()))
else:
session.reply(
'Tremendous! I will deliver this mail to the next '
'recipient without fail! {}'.format(gen_roar()))
else:
if _random.random() < 0.3:
mail_info = self._database.get_old_mail()
else:
if _random.random() < 0.7:
skip_username = session.message['username']
else:
skip_username = None
mail_info = self._database.get_mail(
skip_username=skip_username)
if not mail_info and _random.random() < 0.3:
mail_info = self._database.get_old_mail()
if not mail_info:
session.reply(
'{} Outlandish! There is no new mail! You should send some!'
.format(gen_roar()))
else:
session.reply(
'{roar} I am delivering mail! '
'Here it is, {date}, from {username}: {msg}'.format(
roar=gen_roar(),
username=mail_info['username'].title(),
date=arrow.get(mail_info['timestamp']).humanize(),
msg=mail_info['text']),
multiline=True)
def _xd_rand_command(self, session):
if random.random() < 0.1 or \
session.message['username'] == 'wow_deku_onehand' and \
session.message['text'].strip() == 'xD MingLee':
def rep_func(match):
return '!' if random.random() < 0.6 else '1'
session.say('{} xD MingLee'.format(
re.sub('!', rep_func, gen_roar().lower()))
)
def _rand_case_command(self, session):
text = session.match.group(1).strip()
rand_case_text = ''.join(
char.swapcase() if random.randint(0, 1) else char for char in text
)
formatted_text = '{} Random case! {}'.format(gen_roar(), rand_case_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _sort_command(self, session):
text = session.match.group(1).strip()
if not text:
return
sorted_text = ''.join(sorted(text)).strip()
formatted_text = '{} Sorted! {}'.format(gen_roar(), sorted_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _end_battle(self, winner_username, loser_username):
winner_username = winner_username.lower()
loser_username = loser_username.lower()
_logger.info('End battle')
if frozenset([winner_username, loser_username]) == frozenset([self._our_username, self._battle_session.opponent_username]):
self._bot.send_text(BATTLEBOT_CHANNEL, gen_roar())
else:
_logger.warning('Winner username %s or loser username %s not recognized', winner_username, loser_username)
self._battle_session = None
def _send_to_channels(self, bot, token_button_labels):
text = '[Token] {roar} Detected tokens on: {buttons}' \
.format(
roar=gen_roar(),
buttons=', '.join(sorted(token_button_labels))
)
for channel in self._channels:
_logger.info('Token notify to %s', channel)
bot.send_text(channel, text)
def _pick_command(self, session):
text = session.match.group(1).strip()
if not text:
return
result = random.choice(text.split(',')).strip()
formatted_text = '{} Picked! {}'.format(gen_roar(), result)
self._try_say_or_reply_too_long(formatted_text, session)
def _pick_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if not text:
text = 'heads,tails'
result = _random.choice(text.split(',')).strip()
formatted_text = '{} Picked! {}'.format(gen_roar(), result)
self._try_say_or_reply_too_long(formatted_text, session)
def _pick_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if not text:
text = "heads,tails"
result = _random.choice(text.split(",")).strip()
formatted_text = "{} Picked! {}".format(gen_roar(), result)
self._try_say_or_reply_too_long(formatted_text, session)
def _xd_rand_command(self, session: InboundMessageSession):
if (
_random.random() < 0.1
or session.message["username"] == "wow_deku_onehand"
and session.message["text"].strip() == "xD MingLee"
):
def rep_func(match):
return "!" if _random.random() < 0.6 else "1"
session.say("{} xD MingLee".format(re.sub("!", rep_func, gen_roar().lower())))
def _riot_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if text:
formatted_text = "{} {} or riot! {}".format(gen_roar(), text, gen_roar().upper())
else:
formatted_text = "{} {} {}".format(
gen_roar(),
_random.choice(
(
"Riot, I say! Riot, you may!",
"Riot!",
"{} riot!".format(session.message["nick"]),
"Groudonger riot!",
)
),
gen_roar().upper(),
)
self._try_say_or_reply_too_long(formatted_text, session)
def _discord_presence_sched(self):
unread_count = self._database.get_status_count('unread')
if unread_count:
game_text = 'Mail Delivery: {} unread'.format(unread_count)
else:
game_text = gen_roar()
self._bot.set_discord_presence(game_text)
self._bot.scheduler.enter(300, 0, self._discord_presence_sched)
def _riot_command(self, session):
text = session.match.group(1).strip()
if text:
formatted_text = '{} {} or riot! {}'\
.format(gen_roar(), text, gen_roar().upper())
else:
formatted_text = \
'{} {} {}'.format(
gen_roar(),
random.choice((
'Riot, I say! Riot, you may!',
'Riot!',
'{} riot!'.format(session.message['nick']),
'Groudonger riot!',
)),
gen_roar().upper()
)
self._try_say_or_reply_too_long(formatted_text, session)
def _riot_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
if text:
formatted_text = '{} {} or riot! {}'\
.format(gen_roar(), text, gen_roar().upper())
else:
formatted_text = \
'{} {} {}'.format(
gen_roar(),
_random.choice((
'Riot, I say! Riot, you may!',
'Riot!',
'{} riot!'.format(session.message['nick']),
'Groudonger riot!',
)),
gen_roar().upper()
)
self._try_say_or_reply_too_long(formatted_text, session)
def _mail_command(self, session: InboundMessageSession):
if session.message['channel'] in self._mail_disabled_channels:
session.reply('{} My mail services cannot be used here.'.format(
gen_roar().replace('!', '.')))
return
mail_text = session.match.group(2).strip()
if mail_text:
self._send_mail(mail_text, session)
else:
self._read_mail(session)
def _mail_status_command(self, session):
unread_count = self._database.get_status_count('unread')
read_count = self._database.get_status_count('read')
session.reply(
'{roar} {unread} unread, {read} read, {total} total!'.format(
roar=gen_roar(),
unread=unread_count,
read=read_count,
total=unread_count + read_count
)
)
def _start_battle(self, opponent_username: str):
opponent_username = opponent_username.lower()
_logger.info('Start battle with %s', opponent_username)
self._battle_session = BattleSession(opponent_username,
self._get_type_efficacy_table())
self._bot.send_text(BATTLEBOT_CHANNEL, gen_roar())
self._bot.send_whisper(BATTLEBOT_USERNAME,
'!accept',
allow_command_prefix=True)
def _double_command(self, session):
text = session.match.group(2).strip()
last_message = self._last_message.get(session.message['channel'])
if not text and (session.match.group(1) or not last_message):
text = 'ヽ༼ຈل͜ຈ༽ﾉ DOUBLE TEAM ヽ༼ຈل͜ຈ༽ﾉ'
elif not text:
text = last_message['text']
double_text = ''.join(char * 2 for char in text)
formatted_text = '{} Doubled! {}'.format(gen_roar(), double_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _sort_command(self, session):
text = session.match.group(1).strip()
last_message = self._last_message.get(session.message['channel'])
if not text and last_message:
text = last_message['text']
elif not text:
text = 'Groudonger'
sorted_text = ''.join(sorted(text)).strip()
formatted_text = '{} Sorted! {}'.format(gen_roar(), sorted_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _shuffle_command(self, session):
text = session.match.group(1).strip()
if not text:
return
shuffle_list = list(text)
random.shuffle(shuffle_list)
shuffle_text = ''.join(shuffle_list).strip()
formatted_text = '{} Shuffled! {}'.format(gen_roar(), shuffle_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _reverse_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
last_message = self._last_message.get(session.message["channel"])
if not text and last_message:
text = last_message["text"]
elif not text:
text = "Groudonger"
reversed_text = "".join(reversed(text))
formatted_text = "{} Reversed! {}".format(gen_roar(), reversed_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _reverse_command(self, session: InboundMessageSession):
text = session.match.group(1).strip()
last_message = self._last_message.get(session.message['channel'])
if not text and last_message:
text = last_message['text']
elif not text:
text = 'Groudonger'
reversed_text = ''.join(reversed(text))
formatted_text = '{} Reversed! {}'.format(gen_roar(), reversed_text)
self._try_say_or_reply_too_long(formatted_text, session)
def _double_command(self, session: InboundMessageSession):
text = session.match.group(2).strip()
last_message = self._last_message.get(session.message['channel'])
if not text and (session.match.group(1) or not last_message):
text = 'ヽ༼ຈل͜ຈ༽ﾉ DOUBLE TEAM ヽ༼ຈل͜ຈ༽ﾉ'
elif not text:
text = last_message['text']
double_text = ''.join(char * 2 for char in text)
formatted_text = '{} Doubled! {}'.format(gen_roar(), double_text)
self._try_say_or_reply_too_long(formatted_text, session)
