ryg/royalnet
ryg/royalnet
1
Fork 0
mirror of https://github.com/RYGhub/royalnet.git synced 2024-11-23 19:44:20 +00:00
Code Activity

Add matchmaking service

Browse source
This commit is contained in:
Steffo 2019-01-23 23:11:17 +01:00
parent ab88d70465
commit d4cc3c9398
2 changed files with 215 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
db.py
View file

@ -1215,31 +1215,90 @@ mini_list = [Royal, Telegram, Steam, Dota, LeagueOfLegends, Osu, Discord, Overwa
Terraria13]
class Matchmaker(Base):
__tablename__ = "matchmakers"
class Match(Base):
__tablename__ = "matches"
id = Column(Integer, primary_key=True)
timestamp = Column(DateTime)
creator_id = Column(BigInteger, ForeignKey("telegram.telegram_id"))
creator = relationship("Telegram", backref="matches_created", lazy="joined")
matchmaking_name = Column(String)
matchmaking_desc = Column(Text)
match_title = Column(String)
match_desc = Column(Text)
min_players = Column(Integer)
max_players = Column(Integer)
closed = Column(Boolean, default=False)
timestamp = Column(DateTime)
expires_in = Column(DateTime)
message_id = Column(BigInteger)
players = relationship("MatchmakingEntry", lazy="joined")
def active_players_count(self):
count = 0
for player in self.players:
if player.status == MatchmakingStatus.READY or player.status == MatchmakingStatus.WAIT_FOR_ME:
count += 1
return count
def generate_text(self, session):
player_list = session.query(MatchPartecipation).filter_by(match=self).all()
title = f"<b>{self.match_title}</b>"
description = self.match_desc if self.match_desc else ""
if self.min_players:
minimum = f" <i>(minimo {self.min_players})</i>"
else:
minimum = ""
plist = f"Giocatori{minimum}:\n"
ignore_count = 0
for player in player_list:
if player.status == MatchmakingStatus.WAIT_FOR_ME:
icon = "🕒"
elif player.status == MatchmakingStatus.READY:
icon = "🔵"
elif player.status == MatchmakingStatus.IGNORED:
ignore_count += 1
continue
else:
continue
plist += f"{icon} {player.user.royal.username}\n"
if ignore_count:
ignored = f"❌ <i>{ignore_count} persone non ne hanno voglia.</i>\n"
else:
ignored = ""
if self.max_players:
players = f"[{self.active_players_count()}/{self.max_players}]"
else:
players = f"[{self.active_players_count()}]"
close = f"[matchmaking concluso]\n" if self.closed else ""
message = f"{title} {players}\n" \
f"{description}\n" \
f"{plist}\n" \
f"{ignored}" \
f"{close}"
return message
def __repr__(self):
return f"<Match {self.match_title}>"
class MatchmakingEntry(Base):
__tablename__ = "matchmakingentry"
royal_id = Column(Integer, ForeignKey("royals.id"), primary_key=True)
royal = relationship("Royal", backref="matchmades", lazy="joined")
class MatchmakingStatus(enum.IntEnum):
WAIT_FOR_ME = 1
READY = 2
IGNORED = -1
class MatchPartecipation(Base):
__tablename__ = "matchpartecipations"
__table_args__ = (PrimaryKeyConstraint("user_id", "match_id"),)
user_id = Column(BigInteger, ForeignKey("telegram.telegram_id"))
user = relationship("Telegram", backref="match_partecipations", lazy="joined")
match_id = Column(Integer, ForeignKey("matches.id"))
match = relationship("Match", backref="players", lazy="joined")
status = Column(Integer)
def __repr__(self):
return f"<MatchPartecipation {self.user.username} in {self.match.match_title}>"
# If run as script, create all the tables in the db

175
telegrambot.py
View file

@ -64,19 +64,20 @@ def catch_and_report(func: "function"):
f"```", parse_mode="Markdown")
except Exception:
logger.error(f"Double critical error: {sys.exc_info()}")
if not __debug__:
sentry.user_context({
"id": update.effective_user.id,
"telegram": {
"username": update.effective_user.username,
"first_name": update.effective_user.first_name,
"last_name": update.effective_user.last_name
}
})
sentry.extra_context({
"update": update.to_dict()
})
sentry.captureException()
if __debug__:
raise
sentry.user_context({
"id": update.effective_user.id,
"telegram": {
"username": update.effective_user.username,
"first_name": update.effective_user.first_name,
"last_name": update.effective_user.last_name
}
})
sentry.extra_context({
"update": update.to_dict()
})
sentry.captureException()
return new_func
@ -282,32 +283,69 @@ def cmd_vote(bot: Bot, update: Update):
parse_mode="HTML")
vote.message_id = message.message_id
session.commit()
except Exception:
raise
finally:
session.close()
@catch_and_report
def cmd_mm(bot: Bot, update: Update):
session = db.Session()
try:
user = session.query(db.Telegram).filter_by(telegram_id=update.message.from_user.id).one_or_none()
if user is None:
bot.send_message(update.message.chat.id,
"⚠ Il tuo account Telegram non è registrato a Royalnet!"
" Registrati con `/register@royalgamesbot <nomeutenteryg>`.", parse_mode="Markdown")
return
match = re.match(r"/(?:mm|matchmaking)(?:@royalgamesbot)?(?: (?:([0-9]+)-)?([0-9]+))? (?:per )?([A-Za-z0-9!\-_\. ]+)(?:.*\n(.+))?",
update.message.text)
if match is None:
bot.send_message(update.message.chat.id,
"⚠ Sintassi del comando errata.\n"
"Sintassi: `/matchmaking@royalgamesbot [minplayers]-[maxplayers] per <gamename> \\n [descrizione]`")
return
min_players, max_players, match_name, match_desc = match.group(1, 2, 3, 4)
db_match = db.Match(timestamp=datetime.datetime.now(),
match_title=match_name,
match_desc=match_desc,
min_players=min_players,
max_players=max_players,
creator=user)
session.add(db_match)
session.flush()
inline_keyboard = InlineKeyboardMarkup([[InlineKeyboardButton("🔵 Ci sono!", callback_data="match_ready")],
[InlineKeyboardButton("🕒 Sto arrivando, aspettatemi!", callback_data="match_wait_for_me")],
[InlineKeyboardButton("❌ Non vengo.", callback_data="match_ignore")],
[InlineKeyboardButton("🚩 [termina la ricerca]", callback_data="match_close")]])
message = bot.send_message(update.message.chat.id, db_match.generate_text(session=session),
parse_mode="HTML",
reply_markup=inline_keyboard)
db_match.message_id = message.message_id
session.commit()
finally:
session.close()
@catch_and_report
def on_callback_query(bot: Bot, update: Update):
if update.callback_query.data == "vote_yes":
choice = db.VoteChoices.YES
emoji = "🔵"
elif update.callback_query.data == "vote_no":
choice = db.VoteChoices.NO
emoji = "🔴"
elif update.callback_query.data == "vote_abstain":
choice = db.VoteChoices.ABSTAIN
emoji = "⚫️"
else:
raise NotImplementedError()
if update.callback_query.data.startswith("vote_"):
if update.callback_query.data == "vote_yes":
status = db.VoteChoices.YES
emoji = "🔵"
elif update.callback_query.data == "vote_no":
status = db.VoteChoices.NO
emoji = "🔴"
elif update.callback_query.data == "vote_abstain":
status = db.VoteChoices.ABSTAIN
emoji = "⚫️"
else:
raise NotImplementedError()
session = db.Session()
try:
user = session.query(db.Telegram).filter_by(telegram_id=update.callback_query.from_user.id).one_or_none()
if user is None:
bot.answer_callback_query(update.callback_query.id, show_alert=True,
text="⚠ Il tuo account Telegram non è registrato al RYGdb!"
text="⚠ Il tuo account Telegram non è registrato a Royalnet!"
" Registrati con `/register@royalgamesbot <nomeutenteryg>`.",
parse_mode="Markdown")
return
@ -316,14 +354,14 @@ def on_callback_query(bot: Bot, update: Update):
.one()
answer = session.query(db.VoteAnswer).filter_by(question=question, user=user).one_or_none()
if answer is None:
answer = db.VoteAnswer(question=question, choice=choice, user=user)
answer = db.VoteAnswer(question=question, choice=status, user=user)
session.add(answer)
bot.answer_callback_query(update.callback_query.id, text=f"Hai votato {emoji}.", cache_time=1)
elif answer.choice == choice:
elif answer.choice == status:
session.delete(answer)
bot.answer_callback_query(update.callback_query.id, text=f"Hai ritratto il tuo voto.", cache_time=1)
else:
answer.choice = choice
answer.choice = status
bot.answer_callback_query(update.callback_query.id, text=f"Hai cambiato il tuo voto in {emoji}.",
cache_time=1)
session.commit()
@ -338,8 +376,79 @@ def on_callback_query(bot: Bot, update: Update):
text=question.generate_text(session),
reply_markup=inline_keyboard,
parse_mode="HTML")
except Exception:
raise
finally:
session.close()
elif update.callback_query.data.startswith("match_"):
session = db.Session()
try:
user = session.query(db.Telegram).filter_by(telegram_id=update.callback_query.from_user.id).one_or_none()
if user is None:
bot.answer_callback_query(update.callback_query.id, show_alert=True,
text="⚠ Il tuo account Telegram non è registrato a Royalnet!"
" Registrati con `/register@royalgamesbot <nomeutenteryg>`.",
parse_mode="Markdown")
return
match = session.query(db.Match).filter_by(message_id=update.callback_query.message.message_id).one()
if update.callback_query.data == "match_ready":
status = db.MatchmakingStatus.READY
text = "🔵 Hai detto che sei pronto per giocare!"
elif update.callback_query.data == "match_wait_for_me":
status = db.MatchmakingStatus.WAIT_FOR_ME
text = "🕒 Hai chiesto agli altri di aspettarti."
elif update.callback_query.data == "match_ignore":
status = db.MatchmakingStatus.IGNORED
text = "❌ Non ti interessa questa partita."
elif update.callback_query.data == "match_close":
status = None
if match.creator == user:
match.closed = True
text = "🚩 Matchmaking chiuso!"
for player in match.players:
if player.status == db.MatchmakingStatus.READY or player.status == db.MatchmakingStatus.WAIT_FOR_ME:
try:
bot.send_message(player.user.telegram_id,
f"🚩 Sei pronto? <b>{match.match_title}</b> sta iniziando!",
parse_mode="HTML")
except Exception as e:
logger.warning(f"Failed to notify {player.user.username}: {e}")
else:
bot.answer_callback_query(update.callback_query.id, show_alert=True,
text="⚠ Non sei il creatore di questo match!")
return
else:
raise NotImplementedError()
if status:
if match.closed:
bot.answer_callback_query(update.callback_query.id, show_alert=True,
text="⚠ Il matchmaking è terminato!")
return
if match.max_players and match.active_players_count() >= match.max_players:
bot.answer_callback_query(update.callback_query.id, show_alert=True,
text="⚠ La partita è piena.")
return
player = session.query(db.MatchPartecipation).filter_by(match=match, user=user).one_or_none()
if player is None:
player = db.MatchPartecipation(match=match, status=status.value, user=user)
session.add(player)
else:
player.status = status.value
session.commit()
bot.answer_callback_query(update.callback_query.id, text=text, cache_time=1)
if not match.closed:
inline_keyboard = InlineKeyboardMarkup([[InlineKeyboardButton("🔵 Ci sono!", callback_data="match_ready")],
[InlineKeyboardButton("🕒 Sto arrivando, aspettatemi!",
callback_data="match_wait_for_me")],
[InlineKeyboardButton("❌ Non vengo.",
callback_data="match_ignore")],
[InlineKeyboardButton("🚩 [termina la ricerca]",
callback_data="match_close")]])
else:
inline_keyboard = None
bot.edit_message_text(message_id=update.callback_query.message.message_id,
chat_id=update.callback_query.message.chat.id,
text=match.generate_text(session),
reply_markup=inline_keyboard,
parse_mode="HTML")
finally:
session.close()
@ -601,6 +710,8 @@ def process(arg_discord_connection):
u.dispatcher.add_handler(CommandHandler("markov", cmd_markov))
u.dispatcher.add_handler(CommandHandler("roll", cmd_roll))
u.dispatcher.add_handler(CommandHandler("r", cmd_roll))
u.dispatcher.add_handler(CommandHandler("mm", cmd_mm))
u.dispatcher.add_handler(CommandHandler("matchmaking", cmd_mm))
u.dispatcher.add_handler(CallbackQueryHandler(on_callback_query))
logger.info("Handlers registered.")
u.start_polling()