async def cancel(self, ctx: commands.Context, member: discord.Member):
"""
Cancels the user’s ongoing game
Only works if the game has not been scored yet
"""
with session_scope() as session:
game, participant = get_last_game(player_id=member.id,
server_id=ctx.guild.id,
session=session)
if game and game.winner:
await ctx.send(
"The game has already been scored and cannot be canceled anymore"
)
return
session.delete(game)
await ctx.send(
f"{member.display_name}’s ongoing game was cancelled and deleted from the database"
)
await queue_channel_handler.update_queue_channels(
bot=self.bot, server_id=ctx.guild.id)
await remove_voice_channels(ctx, game)
async def won(
self, ctx: commands.Context,
):
with session_scope() as session:
# Get the latest game
game, participant = get_last_game(
player_id=ctx.author.id, server_id=ctx.guild.id, session=session
)
if not game:
await ctx.send("You have not played a game on this server yet")
return
elif game and game.winner:
await ctx.send(
"Your last game seem to have already been scored\n"
"If there was an issue, please contact an admin"
)
return
elif game.id in self.games_getting_scored_ids:
await ctx.send("There is already a scoring or cancellation message active for this game")
return
else:
self.games_getting_scored_ids.add(game.id)
win_validation_message = await ctx.send(
f"{game.players_ping}"
f"{ctx.author.display_name} wants to score game {game.id} as a win for {participant.side}\n"
f"Result will be validated once 6 players from the game press ✅"
)
validated, players_who_refused = await checkmark_validation(
bot=self.bot,
message=win_validation_message,
validating_players_ids=game.player_ids_list,
validation_threshold=6,
)
# Whatever happens, we’re not scoring it anymore if we get here
self.games_getting_scored_ids.remove(game.id)
if not validated:
await ctx.send("Score input was either cancelled or timed out")
return
# If we get there, the score was validated and we can simply update the game and the ratings
queue_channel_handler.mark_queue_related_message(
await ctx.send(
f"Game {game.id} has been scored as a win for {participant.side} and ratings have been updated"
)
)
categoria = discord.utils.get(ctx.guild.categories, name="âš” Game-%s" % str(game.id))
for channel in categoria.channels:
await channel.delete()
await categoria.delete()
matchmaking_logic.score_game_from_winning_player(player_id=ctx.author.id, server_id=ctx.guild.id)
await ranking_channel_handler.update_ranking_channels(self.bot, ctx.guild.id)
async def champion(self,
ctx: commands.Context,
champion_name: ChampionNameConverter(),
game_id: int = None):
with session_scope() as session:
if not game_id:
game, participant = get_last_game(player_id=ctx.author.id,
server_id=ctx.guild.id,
session=session)
else:
game, participant = (session.query(
Game, GameParticipant).select_from(Game).join(
GameParticipant).filter(Game.id == game_id).filter(
GameParticipant.player_id == ctx.author.id)
).one_or_none()
# We write down the champion
participant.champion_id = champion_name
game_id = game.id
await ctx.send(
f"Champion for game {game_id} was set to "
f"{lol_id_tools.get_name(champion_name, object_type='champion')} for {ctx.author.display_name}"
)
def add_player(player_id: int, role: str, channel_id: int, server_id: int = None, name: str = None):
# Just in case
assert role in roles_list
with session_scope() as session:
game, participant = get_last_game(player_id, server_id, session)
if game and not game.winner:
raise PlayerInGame
# Then check if the player is in a ready-check
if is_in_ready_check(player_id, session):
raise PlayerInReadyCheck
# This is where we add new Players to the server
# This is also useful to automatically update name changes
session.merge(Player(id=player_id, server_id=server_id, name=name))
# Finally, we actually add the player to the queue
queue_player = QueuePlayer(
channel_id=channel_id,
player_id=player_id,
player_server_id=server_id,
role=role,
queue_time=datetime.now(),
)
# We merge for simplicity (allows players to re-queue for the same role)
session.merge(queue_player)
async def cancel(
self,
ctx: commands.Context,
):
"""
Cancels your ongoing game
Will require validation from at least 6 players in the game
Example:
!cancel
"""
with session_scope() as session:
# Get the latest game
game, participant = get_last_game(player_id=ctx.author.id,
server_id=ctx.guild.id,
session=session)
if game and game.winner:
await ctx.send(
"It does not look like you are part of an ongoing game")
return
elif game.id in self.games_getting_scored_ids:
await ctx.send(
"There is already a scoring or cancellation message active for this game"
)
return
else:
self.games_getting_scored_ids.add(game.id)
cancel_validation_message = await ctx.send(
f"{game.players_ping}"
f"{ctx.author.display_name} wants to cancel game {game.id}\n"
f"Game will be canceled once 6 players from the game press ✅")
validated, players_who_refused = await checkmark_validation(
bot=self.bot,
message=cancel_validation_message,
validating_players_ids=game.player_ids_list,
validation_threshold=6,
)
self.games_getting_scored_ids.remove(game.id)
if not validated:
await ctx.send(f"Game {game.id} was not cancelled")
else:
for participant in game.participants.values():
self.players_whose_last_game_got_cancelled[
participant.player_id] = datetime.now()
session.delete(game)
queue_channel_handler.mark_queue_related_message(
await ctx.send(f"Game {game.id} was cancelled"))
def score_game_from_winning_player(player_id: int, server_id: int):
"""
Scores the last game of the player on the server as a *win*
"""
with session_scope() as session:
game, participant = get_last_game(player_id, server_id, session)
game.winner = participant.side
update_trueskill(game, session)
async def cancel(self, ctx: commands.Context):
"""
Scores your last game as a win for (mostly made to be used after !test game)
"""
with session_scope() as session:
game, participant = get_last_game(
player_id=ctx.author.id, server_id=ctx.guild.id, session=session
)
session.delete(game)
await ctx.send(f"{ctx.author.display_name}’s last game was cancelled and deleted from the database")
await queue_channel_handler.update_queue_channels(bot=self.bot, server_id=ctx.guild.id)
async def won(
self,
ctx: commands.Context,
):
"""
Scores your last game as a win
Will require validation from at least 6 players in the game
Example:
!won
"""
# TODO MED PRIO ONLY ONE ONGOING CANCEL/SCORING MESSAGE PER GAME
with session_scope() as session:
# Get the latest game
game, participant = get_last_game(player_id=ctx.author.id,
server_id=ctx.guild.id,
session=session)
if game and game.winner:
await ctx.send(
"Your last game seem to have already been scored\n"
"If there was an issue, please contact an admin")
return
win_validation_message = await ctx.send(
f"{ctx.author.display_name} wants to score game {game.id} as a win for {participant.side}\n"
f"{', '.join([f'<@{discord_id}>' for discord_id in game.player_ids_list])} can validate the result\n"
f"Result will be validated once 6 players from the game press ✅"
)
validated, players_who_refused = await checkmark_validation(
bot=self.bot,
message=win_validation_message,
validating_players_ids=game.player_ids_list,
validation_threshold=6,
timeout=60,
)
if not validated:
await ctx.send("Score input was either cancelled or timed out")
return
# If we get there, the score was validated and we can simply update the game and the ratings
queue_channel_handler.mark_queue_related_message(await ctx.send(
f"Game {game.id} has been scored as a win for {participant.side} and ratings have been updated"
))
matchmaking_logic.score_game_from_winning_player(
player_id=ctx.author.id, server_id=ctx.guild.id)
async def cancel(
self,
ctx: commands.Context,
):
"""
Cancels your ongoing game
Will require validation from at least 6 players in the game
Example:
!cancel
"""
# TODO MED PRIO ONLY ONE ONGOING CANCEL/SCORING MESSAGE PER GAME
with session_scope() as session:
# Get the latest game
game, participant = get_last_game(player_id=ctx.author.id,
server_id=ctx.guild.id,
session=session)
if game and game.winner:
await ctx.send(
"It does not look like you are part of an ongoing game")
return
cancel_validation_message = await ctx.send(
f"{ctx.author.display_name} wants to cancel game {game.id}\n"
f"{', '.join([f'<@{discord_id}>' for discord_id in game.player_ids_list])} can cancel the game\n"
f"Game will be canceled once 6 players from the game press ✅"
)
validated, players_who_refused = await checkmark_validation(
bot=self.bot,
message=cancel_validation_message,
validating_players_ids=game.player_ids_list,
validation_threshold=6,
timeout=60,
)
if not validated:
await ctx.send(f"Game {game.id} was not cancelled")
else:
session.delete(game)
queue_channel_handler.mark_queue_related_message(
await ctx.send(f"Game {game.id} was cancelled"))
async def champion(
self, ctx: commands.Context, champion_name: ChampionNameConverter(), game_id: int = None
):
"""
Saves the champion you used in your last game
Older games can be filled with !champion champion_name game_id
You can find the ID of the games you played with !history
Example:
!champion riven
!champion riven 1
"""
with session_scope() as session:
if not game_id:
game, participant = get_last_game(
player_id=ctx.author.id, server_id=ctx.guild.id, session=session
)
else:
game, participant = (
session.query(Game, GameParticipant)
.select_from(Game)
.join(GameParticipant)
.filter(Game.id == game_id)
.filter(GameParticipant.player_id == ctx.author.id)
).one_or_none()
# We write down the champion
participant.champion_id = champion_name
game_id = game.id
await ctx.send(
f"Champion for game {game_id} was set to "
f"{lol_id_tools.get_name(champion_name, object_type='champion')} for {ctx.author.display_name}"
)
