BaseballBot/GhostBallBot/game.py

266 lines
7.8 KiB
Python
Raw Normal View History

2022-09-24 02:41:03 +00:00
#!/usr/bin/env python3
# Copyright 2022 - c0de <c0de@c0de.dev>
# Licensed under the MIT License (https://opensource.org/licenses/MIT)
# pylint: disable=no-member
"""
A Context Manager / State Machine that keeps track of
a single game instance (there should only be one) in a
Discord channel
"""
2022-09-24 02:41:03 +00:00
import uuid
2022-10-26 04:17:57 +00:00
import datetime
2022-09-24 02:41:03 +00:00
# import dateparser
2022-10-26 04:17:57 +00:00
from database.models import (
database,
GameModel as Game,
GuessModel as Guess,
PlayerModel as Player,
)
2022-09-24 02:41:03 +00:00
2022-10-25 01:05:21 +00:00
async def check_is_running(method, start_new_game=True):
"""
Decorator that determines if the game is running or not
"""
async def wrapper(self):
if self.is_running and start_new_game:
return await self.message.channel.send("A game is already running")
if not self.is_running and not start_new_game:
return await self.message.channel.send("There is no game running")
await method(self)
return await wrapper
2022-10-25 01:00:39 +00:00
2022-10-25 01:05:21 +00:00
2022-10-26 04:17:57 +00:00
class GameManager:
2022-09-24 02:41:03 +00:00
"""
2022-10-25 01:00:39 +00:00
The game state class
2022-09-24 02:41:03 +00:00
2022-10-25 01:00:39 +00:00
This represents a game that exists in a channel
"""
def __init__(self):
2022-09-24 02:41:03 +00:00
# Only one game should run at at time
self.is_running = False
self.commands = {
2022-10-25 01:00:39 +00:00
"ghostball": self.start,
"resolve": self.stop,
"guess": self.guess,
"points": self.points,
"help": self.help,
2022-09-24 02:41:03 +00:00
}
2022-10-26 04:17:57 +00:00
self.game = Game
2022-09-24 02:41:03 +00:00
# Discord message
self.message = None
# Discord client instance
self.discord = None
def __enter__(self):
"""
Allows use of `with Game() as game` for try/except statements
(https://peps.python.org/pep-0343/)
"""
database.connect()
return self
def __exit__(self, exception_type, exception_value, exception_traceback):
"""
2022-10-25 01:00:39 +00:00
Automagically close the database
when this class has ended execution
"""
database.close()
@check_is_running
2022-09-24 02:41:03 +00:00
async def start(self):
"""
Start command - Starts a new game if there isn't already one running
"""
2022-09-24 02:41:03 +00:00
self.is_running = True
# game.pitch_value is unknown at the start of the game
2022-10-26 04:17:57 +00:00
self.game = Game.create(game_id=uuid.uuid4(), server_id=self.message.guild.id)
2022-09-24 02:41:03 +00:00
await self.message.send("Send me your guesses with !guess <number>")
2022-09-24 02:41:03 +00:00
def __stop_args__(self):
2022-09-24 02:41:03 +00:00
pieces = self.message.content.split()
if len(pieces) == 2:
return pieces[1], False, None, None
if len(pieces) == 4:
2022-09-24 02:41:03 +00:00
return pieces[1], True, pieces[2], pieces[3]
return None, False, None, None
2022-10-26 04:17:57 +00:00
async def close_game(self):
"""Update game state database for closing arguments"""
2022-09-24 02:41:03 +00:00
# Determine arguments
pitch_value, has_batter, batter_id, batter_guess = self.__stop_args__()
2022-09-24 02:41:03 +00:00
if not pitch_value:
2022-10-25 01:00:39 +00:00
return await self.message.channel.send(
f"Invalid command <@{ str(self.message.author.id) }>!"
)
2022-09-24 02:41:03 +00:00
if has_batter:
player_id = batter_id[3:]
2022-10-26 04:17:57 +00:00
Guess.create(
2022-10-25 01:00:39 +00:00
game_id=self.game.game_id,
player_id=player_id,
player_name=self.discord.get_user(int(player_id).name),
guess=int(batter_guess),
2022-10-26 04:17:57 +00:00
).save()
2022-09-24 02:41:03 +00:00
# Save the pitch value
2022-10-26 04:17:57 +00:00
self.game.update(
{
Game.pitch_value: pitch_value,
Game.date_ended: datetime.datetime.now(),
}
)
return pitch_value
@check_is_running(stop, start_new_game=False)
async def stop(self):
"""
Stop command - Stops the game if it is currently running,
saves the pitch value, and displays differences
"""
pitch_value = await self.close_game()
2022-09-24 02:41:03 +00:00
2022-10-26 04:17:57 +00:00
# Start calculating difference
2022-09-24 02:41:03 +00:00
2022-10-26 04:17:57 +00:00
# Get all guesses for this game as a list of combo Guess + Player models,
# excluding invalid results, from lowest to highest
# http://docs.peewee-orm.com/en/latest/peewee/query_examples.html#joins-and-subqueries
records = (
Guess.select(
Guess.guess, Player.player_id, Player.player_name, Player.total_points
)
.join(Player)
.where(
(Guess.game_id == self.game.game_id)
& (Guess.guess > 0)
& (Guess.player_id == Player.player_id)
)
.order_by(Guess.guess)
)
# Minimum of 3 players
if len(records) < 2:
self.game = None
self.is_running = False
return await self.message.channel.send(
("Play closed!\n" + "However, there were not enough participants.")
)
message = (
"Closed this play! Here are the results\n"
+ "PLAYER | GUESS | DIFFERENCE | POINTS GAINED | TOTAL POINTS\n"
)
# Determine which guesses are closest and furthest from the pitch_value
guess_values = [record.guess for record in records]
closest_guess_value = min(
guess_values, key=lambda guess: abs(guess - pitch_value)
)
furthest_guess_value = max(
guess_values, key=lambda guess: abs(guess - pitch_value)
2022-10-25 01:00:39 +00:00
)
2022-10-26 04:17:57 +00:00
def get_difference_score():
# TODO: Calculate score based on scoring table
return 0
for record in records:
difference = abs(record.guess - pitch_value)
difference_score = get_difference_score()
# TODO: Update Guess.difference
# TODO: Update Player.total_points
if record.guess == closest_guess_value:
closest_player_id = record.player.player_id
if record.guess == furthest_guess_value:
furthest_player_id = record.player.player_id
message += f"{record.player.player_name} | {record.guess} | {difference} | {difference_score}"
message += (
f"Congrats <@{closest_player_id}>! You were the closest!\n"
+ f"Sorry <@{furthest_player_id}>, you were way off"
)
await self.message.channel.send(message)
2022-09-24 02:41:03 +00:00
# stop and discard game
self.is_running = False
self.game = None
@check_is_running(guess, start_new_game=False)
2022-09-24 02:41:03 +00:00
async def guess(self):
"""
Guess command - Allows the player to add a guess to the current
running game
"""
2022-10-04 00:33:15 +00:00
value = int(self.message.content.split()[1])
if value < 1 or value > 1000:
2022-10-25 01:00:39 +00:00
return await self.message.channel.send(
"Invalid value. It must be between 1 and 1000 inclusive"
2022-10-25 01:00:39 +00:00
)
2022-10-04 00:33:15 +00:00
2022-10-26 04:17:57 +00:00
player_guess, created = Guess.get_or_create(
2022-10-25 01:00:39 +00:00
game_id=self.game.game_id,
player_id=self.message.author.id,
player_name=self.message.author.name,
2022-10-04 00:33:15 +00:00
)
2022-10-26 04:17:57 +00:00
player_guess.update({Guess.guess: value})
2022-10-26 00:23:54 +00:00
if created:
return await self.message.add_reaction(emoji="\N{THUMBS UP SIGN}")
2022-10-26 00:23:54 +00:00
return await self.message.channel.send(
f"<@{ str(self.message.author.id) }> your guess has been updated"
)
2022-10-04 00:33:15 +00:00
2022-09-24 02:41:03 +00:00
async def points(self):
"""
Points command - returns a table ordered from highest to lowest
of the players and their points
"""
# TODO
# value = self.message.content.split()
# try:
# if len(value) > 1:
# timestamp = dateparser.parse(value[1])
# except:
# return await self.message.channel.send("Invalid timestamp. Try again")
return await self.message.channel.send("Sorry, not implemented yet")
2022-09-24 02:41:03 +00:00
async def help(self):
"""help command"""
2022-09-24 02:41:03 +00:00
# TODO: Add help message
help_message = "help"
recipient = await self.discord.fetch_user(self.message.author.id)
await recipient.send(help_message)