NikolajDanger/Gwendolyn
1
0
Fork 0
Code Issues 50 Pull Requests Packages Projects Releases Wiki Activity

✨ reworking a bunch of stuff

Browse Source
This commit is contained in:
Nikolaj
2024-10-28 13:05:06 +01:00
parent f21cbba726
commit bc59bf9b05
142 changed files with 1385 additions and 845 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
gwendolyn/funcs/__init__.py
View File

@ -1,11 +0,0 @@
"""A collection of all Gwendolyn functions."""
__all__ = ["Games", "Money", "LookupFuncs", "StarWars"]
from .games import Money, Games
from .lookup import LookupFuncs
from .other import Other
from .star_wars_funcs import StarWars

6
gwendolyn/funcs/games/__init__.py
View File

@ -1,6 +0,0 @@
"""Functions for games Gwendolyn can play."""
__all__ = ["Money", "Games"]
from .money import Money
from .games_container import Games

966
gwendolyn/funcs/games/blackjack.py
View File

@ -1,966 +0,0 @@
"""
Runs commands, game logic and imaging for blackjack games.
*Classes*
---------
Blackjack
Contains the blackjack game logic.
DrawBlackjack
Draws images of the blackjack table.
"""
import math # Used for flooring decimal numbers
import datetime # Used to generate the game id
import asyncio # Used for sleeping
from discord_slash.context import InteractionContext as IntCont # Used for
# typehints
from discord_slash.context import ComponentContext
from discord.abc import Messageable
from PIL import Image
from gwendolyn.utils import replace_multiple
from .game_base import CardGame, CardDrawer
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 50, 50)
GOLD = (155, 123, 0)
def _is_round_done(game: dict):
"""
Find out if the round is done.
*Parameters*
------------
game: dict
The game to check.
*Returns*
---------
round_done: bool
Whether the round is done.
"""
return all(
hand["hit"] or hand["standing"]
for user_hands in game["user hands"].values() for hand in user_hands
)
class Blackjack(CardGame):
"""
Deals with blackjack commands and gameplay logic.
*Methods*
---------
hit(ctx: IntCont, hand_number: int = 0)
double(ctx: IntCont, hand_number: int = 0)
stand(ctx: IntCont, hand_number: int = 0)
split(ctx: IntCont, hand_number: int = 0)
enter_game(ctx: IntCont, bet: int)
start(ctx: IntCont)
hilo(ctx: IntCont)
shuffle(ctx: IntCont)
cards(ctx: IntCont)
"""
def __init__(self, bot):
"""Initialize the class."""
super().__init__(bot, "blackjack", DrawBlackjack, 4)
default_buttons = ["Hit", "Stand", "Double", "Split"]
self.default_buttons = [(i, [i, "0"], 1) for i in default_buttons]
async def _test_command(self, game: dict, user: str, command: str,
hand_number: int, ctx: IntCont): #pylint:disable=too-many-arguments
valid_command = False
if user not in game["user hands"]:
self.bot.log(f"They tried to {command} without being in the game")
send_msg = f"You have to enter the game before you can {command}"
elif len(game["user hands"][user]) < hand_number:
self.bot.log(f"They tried to {command} with a hand they don't have")
send_msg = "You don't have that many hands"
elif game["round"] <= 0:
self.bot.log(f"They tried to {command} on the 0th round")
send_msg = "You haven't seen your cards yet!"
elif len(game["user hands"][user]) > 1 and hand_number == 0:
self._get_hand_number(ctx, command, game["user hands"][user])
return False
elif game["user hands"][user][max(hand_number-1,0)]["hit"]:
self.bot.log("They've already hit this round")
send_msg = "You've already hit this round"
elif game["user hands"][user][max(hand_number-1,0)]["standing"]:
self.bot.log("They're already standing")
send_msg = "You're already standing"
else:
valid_command = True
if not valid_command:
await ctx.send(send_msg, hidden=True)
return valid_command
def _shuffle_cards(self, channel: str):
"""
Shuffle an amount of decks equal to self.decks_used.
The shuffled cards are placed in the database as the cards that
are used by other blackjack functions.
*Parameters*
------------
channel: str
The id of the channel where the cards will be used.
"""
super()._shuffle_cards(channel)
# Creates hilo file
self.bot.log(f"creating hilo doc for {channel}")
hilo_updater = {"$set": {"_id": channel, "hilo": 0}}
self._update_document(channel, hilo_updater, "hilo")
def _calc_hand_value(self, hand: list):
"""
Calculate the value of a blackjack hand.
*Parameters*
------------
hand: list
The hand to calculate the value of. Each element in the
list is a card represented as a string in the format of
"xy" where x is the number of the card (0, k, q, and j
for 10s, kings, queens and jacks) and y is the suit (d,
c, h or s).
*Returns*
---------
hand_value: int
The blackjack value of the hand.
"""
values = [0]
for card in hand:
card_value = replace_multiple(card[0], ["0", "k", "q", "j"], "10")
if card_value == "a":
values = [i + 1 for i in values] + [i + 11 for i in values]
else:
values = [i+int(card_value) for i in values]
valid_values = [i for i in values if i <= 21]
hand_value = max(valid_values) if valid_values else min(values)
self.bot.log(f"Calculated the value of {hand} to be {hand_value}")
return hand_value
def _draw_card(self, channel: str):
drawn_card = super()._draw_card(channel)
hilo_value = min(1,-1-((self._calc_hand_value([drawn_card])-10)//3))
self._update_document(channel, {"$inc": {"hilo": hilo_value}}, "hilo")
return drawn_card
def _dealer_draw(self, channel: str):
"""
Draw a card for the dealer.
*Parameters*
------------
channel: str
The id of the channel to draw a card for the dealer in.
*Returns*
---------
done: bool
Whether the dealer is done drawing cards.
"""
game = self.access_document(channel)
dealer_hand = game["dealer hand"]
if self._calc_hand_value(dealer_hand) < 17:
dealer_hand.append(self._draw_card(channel))
dealer_updater = {"$set": {"dealer hand": dealer_hand}}
self._update_document(channel, dealer_updater)
done = False
else:
done = True
if self._calc_hand_value(dealer_hand) > 21:
self._update_document(channel, {"$set": {"dealer busted": True}})
return done
def _blackjack_continue(self, channel: str):
"""
Continues the blackjack game to the next round.
*Parameters*
------------
channel: str
The id of the channel the blackjack game is in
*Returns*
---------
send_message: str
The message to send to the channel.
all_standing: bool
If all players are standing.
gameDone: bool
If the game has finished.
"""
self.bot.log("Continuing blackjack game")
game = self.access_document(channel)
self._update_document(channel, {"$inc": {"round": 1}})
message = self.long_strings["Blackjack all players standing"]
all_standing = True
pre_all_standing = True
done = False
if game["all standing"]:
self.bot.log("All are standing")
done = self._dealer_draw(channel)
message = "The dealer draws a card."
self.bot.log("Testing if all are standing")
for user, user_hands in game["user hands"].items():
standing_test = (self._test_if_standing(user_hands))
hand_updater = {"$set": {"user hands."+user: standing_test[0]}}
self._update_document(channel, hand_updater)
if not standing_test[1]:
all_standing = False
if not standing_test[2]:
pre_all_standing = False
if all_standing:
self._update_document(channel, {"$set": {"all standing": True}})
if done:
message = "The dealer is done drawing cards"
return message, True, done
if pre_all_standing:
return "", True, done
send_message = self.long_strings["Blackjack commands"]
if game["round"] == 0:
send_message = send_message.format(
self.long_strings["Blackjack first round"])
else:
send_message = send_message.format("")
return send_message, False, done
def _test_if_standing(self, user_hands: list):
"""
Test if a player is standing on all their hands.
Also resets the hand if it's not standing
*Parameters*
------------
hand: dict
The hands to test and reset.
*Returns*
---------
hand: dict
The reset hand.
all_standing: bool
If the player is standing on all their hands.
pre_all_standing: bool
Is true if all_standing is True, or if a player has done
something equivalent to standing but still needs to see
the newly drawn card.
"""
# If the user has not hit, they are by definition standing.
all_standing = True
pre_all_standing = True
for hand in user_hands:
if not hand["hit"]:
hand["standing"] = True
if not hand["standing"]:
all_standing = False
if self._calc_hand_value(hand["hand"]) >= 21 or hand["doubled"]:
hand["standing"] = True
else:
pre_all_standing = False
hand["hit"] = False
return user_hands, all_standing, pre_all_standing
async def _blackjack_finish(self, channel: Messageable):
"""
Generate the winnings message after the blackjack game ends.
*Parameters*
------------
channel: str
The id of the channel the game is in.
*Returns*
---------
final_winnings: str
The winnings message.
"""
final_winnings = "*Final Winnings:*\n"
game = self.access_document(str(channel.id))
for user in game["user hands"]:
winnings, net_winnings, reason = self._calc_winning(
game["user hands"][user],
self._calc_hand_value(game["dealer hand"]),
game["dealer blackjack"],
game["dealer busted"]
)
user_name = self.bot.database_funcs.get_name(user)
if winnings < 0:
final_winnings += f"{user_name} lost"
else:
final_winnings += f"{user_name} won"
if abs(winnings) == 1:
final_winnings += " 1 GwendoBuck"
else:
final_winnings += f" {abs(winnings)} GwendoBucks"
final_winnings += f" {reason}\n"
self.bot.money.addMoney(user, net_winnings)
await self._end_game(channel)
return final_winnings
def _calc_winning(self, user_hands: dict, dealer_value: int,
dealer_blackjack: bool, dealer_busted: bool):
"""
Calculate how much a user has won/lost in the blackjack game.
*Parameters*
------------
hand: dict
The hand to calculate the winnings of.
dealer_value: int
The dealer's hand value.
top_level: bool
If the input hand is _all_ if the player's hands. If
False, it's one of the hands resulting from a split.
dealer_blackjack: bool
If the dealer has a blackjack.
dealer_busted: bool
If the dealer busted.
*Returns*
---------
winnings: int
How much the player has won/lost.
net_winnings: int
winnings minus the original bet. This is added to the
user's account, since the bet was removed from their
account when they placed the bet.
reason: str
The reason for why they won/lost.
"""
self.bot.log("Calculating winnings")
reason = ""
winnings = 0
net_winnings = 0
for hand in user_hands:
winnings += -1 * hand["bet"]
hand_value = self._calc_hand_value(hand["hand"])
states = [
(dealer_blackjack, "dealer blackjack", 0),
(hand["blackjack"], "blackjack", math.floor(2.5 * hand["bet"])),
(hand["busted"], "busted", 0),
(dealer_busted, dealer_busted, 2*hand["bet"]),
(hand_value == dealer_value, "pushed", hand["bet"]),
(hand_value > dealer_value, "highest value", 2 * hand["bet"]),
(True, "highest value", 0)
]
for state in states:
if state[0]:
reason += f"({state[1]})"
net_winnings += state[2]
break
winnings += net_winnings
return winnings, net_winnings, reason
async def _blackjack_loop(self, channel, game_round: int, game_id: str):
"""
Run blackjack logic and continue if enough time passes.
*Parameters*
------------
channel: guildChannel or DMChannel
The channel the game is happening in.
game_round: int
The round to start.
game_id: str
The ID of the game.
"""
self.bot.log(f"Loop {game_round}", str(channel.id))
new_message, all_standing, game_done = self._blackjack_continue(
str(channel.id)
)
if new_message != "":
self.bot.log(new_message, str(channel.id))
await channel.send(new_message)
if not game_done:
await self._delete_old_image(channel)
buttons = None if all_standing else self.default_buttons
await self._send_image(channel, buttons)
await asyncio.sleep([120,5][all_standing])
if not self._test_document(str(channel.id)):
self.bot.log(f"Ending loop on round {game_round}", str(channel.id))
return
game = self.access_document(str(channel.id))
if game_round != game["round"] or game_id != game["game_id"]:
self.bot.log(f"Ending loop on round {game_round}", str(channel.id))
return
if not game_done:
log_message = f"Loop {game_round} starting a new blackjack loop"
self.bot.log(log_message, str(channel.id))
await self._blackjack_loop(channel, game_round+1, game_id)
else:
await channel.send(await self._blackjack_finish(channel))
async def _get_hand_number(self, ctx: IntCont, command: str,
hands_amount: int):
buttons = [
(str(i+1), [command, "0", str(i+1)], 1) for i in range(hands_amount)
]
await ctx.send(
f"Which hand do you want to {command}?",
hidden=True,
components=self._get_action_rows(buttons)
)
async def _hit(self, ctx: IntCont, hand_number: int = 0):
"""
Hit on a hand.
*Parameters*
------------
ctx: IntCont
The context of the command.
hand_number: int = 1
The number of the hand to hit.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
game = self.access_document(channel)
if not await self._test_command(game, user, "hit", hand_number, ctx):
return
hand = game["user hands"][user][max(hand_number-1,0)]
hand["hand"].append(self._draw_card(channel))
hand["hit"] = True
hand_value = self._calc_hand_value(hand["hand"])
if hand_value > 21:
hand["busted"] = True
hand_path = f"user hands.{user}.{max(hand_number-1,0)}"
self._update_document(channel, {"$set": {hand_path: hand}})
game = self.access_document(channel)
await ctx.send(f"{ctx.author.display_name} hit")
self.bot.log("They succeeded")
if _is_round_done(game):
game_id = game["game_id"]
self.bot.log("Hit calling self._blackjack_loop()", channel)
await self._blackjack_loop(
ctx.channel, game["round"]+1, game_id
)
async def _double(self, ctx: IntCont, hand_number: int = 0):
"""
Double a hand.
*Parameters*
------------
ctx: IntCont
The context of the command.
hand_number: int = 0
The number of the hand to double.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
game = self.access_document(channel)
balance = self.bot.money.checkBalance(user)
if not await self._test_command(game, user, "double", hand_number, ctx):
return
if len(game["user hands"][user][max(hand_number-1,0)]["hand"]) != 2:
await ctx.send("You can only double on the first round")
self.bot.log("They tried to double after round 1")
elif balance < game["user hands"][user][max(hand_number-1,0)]["bet"]:
await ctx.send("You can't double when you don't have enough money")
self.bot.log("They tried to double without having enough money")
else:
hand = game["user hands"][user][max(hand_number-1,0)]
self.bot.money.addMoney(user, -1 * hand["bet"])
hand["hand"].append(self._draw_card(channel))
hand["hit"] = True
hand["doubled"] = True
hand["bet"] += hand["bet"]
if self._calc_hand_value(hand["hand"]) > 21:
hand["busted"] = True
hand_path = f"user hands.{user}.{max(hand_number-1,0)}"
self._update_document(channel, {"$set": {hand_path: hand}})
game = self.access_document(channel)
user_name = self.bot.database_funcs.get_name(user)
send_message = self.long_strings["Blackjack double"]
await ctx.send(send_message.format(hand["bet"], user_name))
self.bot.log("They succeeded")
if _is_round_done(game):
game_id = game["game_id"]
self.bot.log("Double calling self._blackjack_loop()", channel)
await self._blackjack_loop(
ctx.channel, game["round"]+1, game_id
)
async def _stand(self, ctx: IntCont, hand_number: int = 0):
"""
Stand on a hand.
*Parameters*
------------
ctx: IntCont
The context of the command.
hand_number: int = 0
The number of the hand to stand on.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
game = self.access_document(channel)
if not await self._test_command(game, user, "stand", hand_number, ctx):
return
hand = game["user hands"][user][max(hand_number-1,0)]
hand["standing"] = True
hand_path = f"user hands.{user}.{max(hand_number-1,0)}"
self._update_document(channel, {"$set": {hand_path: hand}})
game = self.access_document(channel)
send_message = f"{ctx.author.display_name} is standing"
log_message = "They succeeded"
await ctx.send(send_message)
self.bot.log(log_message)
if _is_round_done(game):
game_id = game["game_id"]
self.bot.log("Stand calling self._blackjack_loop()", channel)
await self._blackjack_loop(ctx.channel, game["round"]+1, game_id)
async def _split(self, ctx: IntCont, hand_number: int = 0):
"""
Split a hand.
*Parameters*
------------
ctx: IntCont
The context of the command.
hand_number: int = 0
The number of the hand to split.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
game = self.access_document(channel)
if not await self._test_command(game, user, "split", hand_number, ctx):
return
old_hand = game["user hands"][user][max(hand_number-1,0)]
if len(game["user hands"][user]) > 3:
await ctx.send("You can only split 3 times")
self.bot.log("They tried to split more than three times")
elif len(old_hand["hand"]) != 2:
await ctx.send("You can only split on the first round")
self.bot.log("They tried to split after the first round")
elif len({self._calc_hand_value([i]) for i in old_hand["hand"]}) != 1:
await ctx.send(self.long_strings["Blackjack different cards"])
self.bot.log("They tried to split two different cards")
elif self.bot.money.checkBalance(user) < old_hand["bet"]:
await ctx.send("You don't have enough GwendoBucks")
self.bot.log("They didn't have enough GwendoBucks")
else:
self.bot.money.addMoney(user, -1 * old_hand["bet"])
old_hand["hit"] = True
hands = [old_hand, {
"hand": [old_hand["hand"].pop(1), self._draw_card(channel)],
"bet": old_hand["bet"], "standing": False,
"busted": False, "blackjack": False, "hit": True,
"doubled": False
}]
old_hand["hand"].append(self._draw_card(channel))
for i, hand in enumerate(hands):
if self._calc_hand_value(hand["hand"]) > 21:
hands[i]["busted"] = True
elif self._calc_hand_value(hand["hand"]) == 21:
hands[i]["blackjack"] = True
game["user hands"][user][max(hand_number-1,0)] = hands[0]
game["user hands"][user].append(hands[1])
updater = {"$set": {f"user hands.{user}": game["user hands"][user]}}
self._update_document(channel, updater)
send_message = self.long_strings["Blackjack split"]
user_name = self.bot.database_funcs.get_name(user)
await ctx.send(send_message.format(user_name))
self.bot.log("They succeeded")
game = self.access_document(channel)
if _is_round_done(game):
game_id = game["game_id"]
self.bot.log("Split calling self._blackjack_loop()", channel)
await self._blackjack_loop(
ctx.channel, game["round"]+1, game_id
)
async def enter_game(self, ctx: IntCont, bet: int):
"""
Enter the blackjack game.
*Parameters*
------------
ctx: IntCont
The context of the command.
bet: int
The bet to enter with.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
game = self.access_document(channel)
user_name = self.bot.database_funcs.get_name(user)
self.bot.log(f"{user_name} is trying to join the Blackjack game")
if user in game["user hands"]:
await ctx.send("You're already in the game!")
self.bot.log("They're already in the game")
elif len(game["user hands"]) >= 5:
await ctx.send("There can't be more than 5 players in a game")
self.bot.log("There were already 5 players in the game")
elif game["round"] != 0:
await ctx.send("The table is no longer taking bets")
self.bot.log("They tried to join after the game begun")
elif bet < 0:
await ctx.send("You can't bet a negative amount")
self.bot.log("They tried to bet a negative amount")
elif self.bot.money.checkBalance(user) < bet:
await ctx.send("You don't have enough GwendoBucks")
self.bot.log("They didn't have enough GwendoBucks")
else:
self.bot.money.addMoney(user, -1 * bet)
player_hand = [self._draw_card(channel) for _ in range(2)]
new_hand = [{
"hand": player_hand, "bet": bet, "standing": False,
"busted": False,
"blackjack": self._calc_hand_value(player_hand) == 21,
"hit": True, "doubled": False
}]
updater = {"$set": {f"user hands.{user}": new_hand}}
self._update_document(channel, updater)
send_message = "{} entered the game with a bet of {} GwendoBucks"
await ctx.send(send_message.format(user_name, bet))
self.bot.log(send_message.format(user_name, bet))
async def start(self, ctx: IntCont):
"""
Start a blackjack game.
*Parameters*
------------
ctx: IntCont
The context of the command.
"""
await self.bot.defer(ctx)
channel = str(ctx.channel_id)
blackjack_min_cards = 50
self.bot.log("Starting blackjack game")
await ctx.send("Starting a new game of blackjack")
cards_left = 0
if self._test_document(channel, "cards"):
cards = self.access_document(channel, "cards")
cards_left = len(cards["cards"])
# Shuffles if not enough cards
if cards_left < blackjack_min_cards:
self._shuffle_cards(channel)
await ctx.channel.send("Shuffling the deck...")
self.bot.log(f"Trying to start a blackjack game in {channel}")
if self._test_document(channel):
await ctx.channel.send(self.long_strings["Blackjack going on"])
self.bot.log("There was already a game going on")
return
dealer_hand = [self._draw_card(channel), self._draw_card(channel)]
game_id = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
new_game = {
"dealer hand": dealer_hand,
"dealer busted": False, "game_id": game_id,
"dealer blackjack": (self._calc_hand_value(dealer_hand) == 21),
"user hands": {}, "all standing": False, "round": 0
}
await ctx.channel.send(self.long_strings["Blackjack started"])
labels = [0] + [10**i for i in range(4)]
betting_buttons = [
(f"Bet {i}", ["bet", "0", str(i)], 1) for i in labels
]
await self._start_new(ctx.channel, new_game, betting_buttons)
await asyncio.sleep(30)
game = self.access_document(channel)
if len(game["user hands"]) == 0:
await ctx.channel.send("No one entered the game. Ending the game.")
await ctx.channel.send(await self._blackjack_finish(ctx.channel))
return
game_id = game["game_id"]
# Loop of game rounds
self.bot.log("start() calling _blackjack_loop()", channel)
await self._blackjack_loop(ctx.channel, 1, game_id)
async def hilo(self, ctx: IntCont):
"""
Get the hilo of the blackjack game.
*Parameters*
------------
ctx: IntCont
The context of the command.
"""
data = self.access_document(str(ctx.channel_id), "hilo", False)
hilo = data["hilo"] if data else 0
await ctx.send(f"Hi-lo value: {hilo}", hidden=True)
async def shuffle(self, ctx: IntCont):
"""
Shuffle the cards used for blackjack.
*Parameters*
------------
ctx: IntCont
The context of the command.
"""
self._shuffle_cards(str(ctx.channel_id))
await ctx.send("Shuffling the deck...")
async def cards(self, ctx: IntCont):
"""
Get how many cards are left for blackjack.
*Parameters*
------------
ctx: IntCont
The context of the command.
"""
cards = self.access_document(str(ctx.channel_id), "cards", False)
cards_left = len(cards["cards"]) if cards else 0
decks_left = round(cards_left/52, 1) if cards else 0
send_message = f"Cards left:\n{cards_left} cards, {decks_left} decks"
await ctx.send(send_message, hidden=True)
async def decode_interaction(self, ctx: ComponentContext, info: list[str]):
if info[0].lower() == "bet":
await self.enter_game(ctx, int(info[2]))
elif info[0].lower() == "hit":
await self._hit(ctx, int(info[2]) if len(info) > 2 else 0)
elif info[0].lower() == "stand":
await self._stand(ctx, int(info[2]) if len(info) > 2 else 0)
elif info[0].lower() == "double":
await self._double(ctx, int(info[2]) if len(info) > 2 else 0)
elif info[0].lower() == "split":
await self._split(ctx, int(info[2]) if len(info) > 2 else 0)
class DrawBlackjack(CardDrawer):
"""
Draws the blackjack image.
*Methods*
---------
*Attributes*
------------
bot: Gwendolyn
The instance of the bot.
PLACEMENT: list
The order to place the user hands in.
"""
# pylint: disable=too-few-public-methods
def __init__(self, bot, game: Blackjack):
"""Initialize the class."""
super().__init__(bot, game)
# pylint: disable=invalid-name
self.PLACEMENT = [2, 1, 3, 0, 4]
# pylint: enable=invalid-name
self._set_card_size(197)
def _draw_dealer_hand(self, game: dict, table: Image.Image):
dealer_hand = self._draw_hand(
game["dealer hand"],
not game["all standing"],
game["dealer busted"] if game["all standing"] else False,
game["dealer blackjack"] if game["all standing"] else False
)
paste_position = (800-self.CARD_BORDER, 20-self.CARD_BORDER)
table.paste(dealer_hand, paste_position, dealer_hand)
def _draw_player_name(self, user: str, placement: int, table: Image.Image):
user_name = self.bot.database_funcs.get_name(user)
font, font_size = self._adjust_font(50, user_name, 360)
text_width, text_height = font.getsize(user_name)
text_x = 32+(384*placement)+117-(text_width//2)
text_y = 960+text_height
colors = [BLACK, WHITE]
text_image = self._draw_shadow_text(user_name, colors, font_size)
table.paste(text_image, (text_x, text_y), text_image)
def _draw_player_hands(self, all_hands: dict, table: Image.Image):
for i, (user, user_hands) in enumerate(all_hands.items()):
hand_images = []
position_x = 32-self.CARD_BORDER+(384*self.PLACEMENT[i])
for hand in user_hands:
hand_images.append(self._draw_hand(
hand["hand"],
False,
hand["busted"],
hand["blackjack"]
))
for index, image in enumerate(hand_images):
position_y = 840
position_y -= self.CARD_BORDER + (140 * (len(user_hands)-index))
position = (position_x, position_y)
table.paste(image, position, image)
self._draw_player_name(user, self.PLACEMENT[i], table)
def _draw_image(self, game: dict, table: Image.Image):
"""
Draw the table image.
*Parameters*
------------
channel: str
The id of the channel the game is in.
"""
self._draw_dealer_hand(game, table)
self._draw_player_hands(game["user hands"], table)
def _draw_hand(self, hand: dict, dealer: bool, busted: bool,
blackjack: bool):
"""
Draw a hand.
*Parameters*
------------
hand: dict
The hand to draw.
dealer: bool
If the hand belongs to the dealer who hasn't shown
their second card.
busted: bool
If the hand is busted.
blackjack: bool
If the hand has a blackjack.
*Returns*
---------
background: Image
The image of the hand.
"""
self.bot.log("Drawing hand {hand}, {busted}, {blackjack}")
background = self._draw_cards(hand, int(dealer))
if busted or blackjack:
if busted:
text = "BUSTED"
last_color = RED
font_size = 60
elif blackjack:
text = "BLACKJACK"
last_color = GOLD
font_size = 35
colors = [BLACK, WHITE, last_color]
text_image = self._draw_shadow_text(text, colors, font_size)
width = background.size[0]
text_width = self._get_font(font_size).getsize(text)[0]
text_position = (int(width/2)-int(text_width/2), 85)
background.paste(text_image, text_position, text_image)
return background

1129
gwendolyn/funcs/games/connect_four.py
View File

File diff suppressed because it is too large Load Diff

319
gwendolyn/funcs/games/game_base.py
View File

@ -1,319 +0,0 @@
"""Base class for the games."""
import random
from typing import Union
from discord import File, User
from discord.abc import Messageable
from discord_slash.utils.manage_components import (create_button,
create_actionrow)
from discord_slash.context import InteractionContext as IntCont
from PIL import ImageFont, Image, ImageDraw
from gwendolyn.exceptions import GameNotInDatabase
from gwendolyn.utils import encode_id
class GameBase():
"""The base class for the games."""
def __init__(self, bot, game_name: int, drawer):
"""Initialize the class."""
self.bot = bot
self.long_strings = self.bot.long_strings
self.resources = "gwendolyn/resources/games/"
self.game_name = game_name
self.draw = drawer(bot, self)
def _get_action_rows(self, buttons: list[tuple[str, list]]):
self.bot.log("Generation action rows")
button_objects = []
for label, data, style in buttons:
custom_id = encode_id([self.game_name] + data)
button_objects.append(create_button(
style=style,
label=label,
custom_id=custom_id
))
action_rows = []
for i in range(((len(button_objects)-1)//5)+1):
action_rows.append(create_actionrow(*button_objects[i*5:i*5+5]))
return action_rows
async def _send_image(self, channel: Messageable,
buttons: list[tuple[str, list]] = None, delete=True):
self.draw.draw(str(channel.id))
file_path = f"{self.resources}images/{self.game_name}{channel.id}.png"
old_image = await channel.send(
file=File(file_path), delete_after=120 if delete else None)
if buttons is not None and len(buttons) < 25:
await old_image.edit(components = self._get_action_rows(buttons))
return old_image
class DatabaseGame(GameBase):
"""The base class for the games."""
def __init__(self, bot, game_name, drawer):
"""Initialize the class."""
super().__init__(bot, game_name, drawer)
self.database = self.bot.database
self.old_images_path = f"{self.resources}old_images/{self.game_name}"
def access_document(self, channel: str, collection_name: str="games",
raise_missing_error: bool=True):
collection = self.bot.database[f"{self.game_name} {collection_name}"]
game = collection.find_one({"_id": channel})
if game is None and raise_missing_error:
raise GameNotInDatabase(self.game_name, channel)
return game
def _test_document(self, channel: str, collection_name: str="games"):
collection = self.bot.database[f"{self.game_name} {collection_name}"]
game = collection.find_one({"_id": channel})
return game is not None
def _update_document(self, channel: str, updater: dict,
collection_name: str="games"):
self.database[f"{self.game_name} {collection_name}"].update_one(
{"_id": channel},
updater,
upsert=True
)
def _delete_document(self, channel: str, collection_name: str="games"):
self.database[f"{self.game_name} {collection_name}"].delete_one(
{"_id": channel}
)
def _insert_document(self, data: dict, collection_name: str="games"):
self.database[f"{self.game_name} {collection_name}"].insert_one(data)
async def _delete_old_image(self, channel: Messageable):
with open(self.old_images_path + str(channel.id), "r") as file_pointer:
old_image = await channel.fetch_message(int(file_pointer.read()))
await old_image.delete()
async def _send_image(self, channel: Messageable,
buttons: list[tuple[str, list]] = None, delete=True):
old_image = await super()._send_image(channel, buttons, delete)
with open(self.old_images_path + str(channel.id), "w") as file_pointer:
file_pointer.write(str(old_image.id))
async def _start_new(self, channel: Messageable, new_game: dict,
buttons: list[tuple[str, list]] = None,
delete = True):
new_game['_id'] = str(channel.id)
self._insert_document(new_game)
await self._send_image(channel, buttons, delete)
async def _end_game(self, channel: Messageable):
await self._delete_old_image(channel)
await self._send_image(channel, delete=False)
self._delete_document(str(channel.id))
class CardGame(DatabaseGame):
"""The class for card games."""
def __init__(self, bot, game_name, drawer, deck_used):
"""Initialize the class."""
super().__init__(bot, game_name, drawer)
self.decks_used = deck_used
def _shuffle_cards(self, channel: str):
self.bot.log(f"Shuffling cards for {self.game_name}")
with open(f"{self.resources}deck_of_cards.txt", "r") as file_pointer:
deck = file_pointer.read()
all_decks = deck.split("\n") * self.decks_used
random.shuffle(all_decks)
self._update_document(
channel,
{"$set": {"_id": channel, "cards": all_decks}},
"cards"
)
def _draw_card(self, channel: str):
"""
Draw a card from the stack.
*Parameters*
------------
channel: str
The id of the channel the card is drawn in.
"""
self.bot.log("drawing a card")
drawn_card = self.access_document(channel, "cards")["cards"][0]
self._update_document(channel, {"$pop": {"cards": -1}}, "cards")
return drawn_card
class BoardGame(GameBase):
async def _test_opponent(self, ctx: IntCont, opponent: Union[int, User]):
if isinstance(opponent, int):
# Opponent is Gwendolyn
if opponent in range(1, 6):
difficulty = int(opponent)
difficulty_text = f" with difficulty {difficulty}"
opponent = self.bot.user.id
else:
await ctx.send("Difficulty doesn't exist")
self.bot.log("They challenged a difficulty that doesn't exist")
return False
elif isinstance(opponent, User):
if opponent.bot:
# User has challenged a bot
if opponent == self.bot.user:
# It was Gwendolyn
difficulty = 3
difficulty_text = f" with difficulty {difficulty}"
opponent = self.bot.user.id
else:
await ctx.send("You can't challenge a bot!")
self.bot.log("They tried to challenge a bot")
return False
else:
# Opponent is another player
if ctx.author != opponent:
opponent = opponent.id
difficulty = 5
difficulty_text = ""
else:
await ctx.send("You can't play against yourself")
self.bot.log("They tried to play against themself")
return False
return opponent, (difficulty, difficulty_text)
class BaseDrawer():
"""Class for drawing games."""
def __init__(self, bot, game: GameBase):
self.bot = bot
self.game = game
self.fonts_path = "gwendolyn/resources/fonts/"
self.font_name = "futura-bold"
self.resources = game.resources
game_name = game.game_name
self.default_image = f"{self.resources}default_images/{game_name}.png"
self.default_size = None
self.default_color = None
self.images_path = f"{self.resources}images/{game_name}"
def _get_size(self, game: dict):
return self.default_size
def _draw_image(self, game: dict, image: Image.Image):
pass
def draw(self, channel: str):
game = self.game.access_document(channel)
if self.default_image is not None:
image = Image.open(self.default_image)
else:
image = Image.new("RGB", self._get_size(game), self.default_color)
self._draw_image(game, image)
self._save_image(image, channel)
def _get_font(self, size: int, font_name: str = None):
if font_name is None:
font_name = self.font_name
return ImageFont.truetype(f"{self.fonts_path}{font_name}.ttf", size)
def _adjust_font(self, max_font_size: int, text: str, max_text_size: int,
font_name: str = None):
font_size = max_font_size
font = self._get_font(font_size, font_name)
text_width = font.getsize(text)[0]
while text_width > max_text_size:
font_size -= 1
font = self._get_font(font_size, font_name)
text_width = font.getsize(text)[0]
return font, font_size
def _save_image(self, image: Image.Image, channel: str):
self.bot.log("Saving image")
image.save(f"{self.images_path}{channel}.png")
def _draw_shadow_text(self, text: str, colors: list[tuple[int, int, int]],
font_size: int):
font = self._get_font(font_size)
offset = font_size//20
shadow_offset = font_size//10
text_size = list(font.getsize(text))
text_size[0] += 1 + (offset * 2)
text_size[1] += 1 + (offset * 2) + shadow_offset
image = Image.new("RGBA", tuple(text_size), (0, 0, 0, 0))
text_image = ImageDraw.Draw(image)
for color_index, color in enumerate(colors[:-1]):
color_offset = offset//(color_index+1)
if color_index == 0:
color_shadow_offset = shadow_offset
else:
color_shadow_offset = 0
for i in range(4):
x_pos = [-1,1][i % 2] * color_offset
y_pos = [-1,1][(i//2) % 2] * color_offset + color_shadow_offset
position = (offset + x_pos, offset + y_pos)
text_image.text(position, text, fill=color, font=font)
text_image.text((offset, offset), text, fill=colors[-1], font=font)
return image
class CardDrawer(BaseDrawer):
def __init__(self, bot, game: GameBase):
super().__init__(bot, game)
self.cards_path = f"{self.resources}cards/"
# pylint: disable=invalid-name
self.CARD_WIDTH = 691
self.CARD_HEIGHT = 1065
self.CARD_BORDER = 100
self.CARD_OFFSET = 125
# pylint: enable=invalid-name
def _set_card_size(self, wanted_card_width: int):
ratio = wanted_card_width / self.CARD_WIDTH
self.CARD_WIDTH = wanted_card_width
self.CARD_HEIGHT = int(self.CARD_HEIGHT * ratio)
self.CARD_BORDER = int(self.CARD_BORDER * ratio)
self.CARD_OFFSET = int(self.CARD_OFFSET * ratio)
def _draw_cards(self, hand: list[str], hidden_cards: int = 0):
image_width = (self.CARD_BORDER * 2) + self.CARD_WIDTH
image_width += (self.CARD_OFFSET * (len(hand)-1))
image_size = (image_width, (self.CARD_BORDER * 2) + self.CARD_HEIGHT)
background = Image.new("RGBA", image_size, (0, 0, 0, 0))
for i, card in enumerate(hand):
position = (
self.CARD_BORDER + (self.CARD_OFFSET*i),
self.CARD_BORDER
)
if i + hidden_cards < len(hand):
card_image = Image.open(f"{self.cards_path}{card.upper()}.png")
else:
card_image = Image.open(f"{self.cards_path}red_back.png")
card_image = card_image.resize(
(self.CARD_WIDTH, self.CARD_HEIGHT),
resample=Image.BILINEAR
)
background.paste(card_image, position, card_image)
return background

50
gwendolyn/funcs/games/games_container.py
View File

@ -1,50 +0,0 @@
"""
Has a container for game functions.
*Classes*
---------
Games
Container for game functions.
"""
from .invest import Invest
from .trivia import Trivia
from .blackjack import Blackjack
from .connect_four import ConnectFour
from .hangman import Hangman
from .hex import HexGame
from .wordle import WordleGame
class Games():
"""
Contains game classes.
*Attributes*
------------
bot: Gwendolyn
The instance of Gwendolyn.
invest
Contains investment functions.
blackjack
Contains blackjack functions.
connect_four
Contains connect four functions.
hangman
Contains hangman functions.
hex
Contains hex functions
"""
def __init__(self, bot):
"""Initialize the container."""
self.bot = bot
self.invest = Invest(bot)
self.trivia = Trivia(bot)
self.blackjack = Blackjack(bot)
self.connect_four = ConnectFour(bot)
self.hangman = Hangman(bot)
self.hex = HexGame(bot)
self.wordle = WordleGame(bot)

657
gwendolyn/funcs/games/hangman.py
View File

@ -1,657 +0,0 @@
"""
Deals with commands and logic for hangman games.
*Classes*
---------
Hangman()
Deals with the game logic of hangman.
DrawHangman()
Draws the image shown to the player.
"""
import os
import datetime # Used for generating the game id
import string # string.ascii_uppercase used
import math # Used by DrawHangman(), mainly for drawing circles
import random # Used to draw poorly
import requests # Used for getting the word in Hangman.start()
import discord # Used for discord.file and type hints
from discord_slash.utils.manage_components import (create_button,
create_actionrow)
from discord_slash.model import ButtonStyle
from discord_slash.context import SlashContext, ComponentContext
# Used for typehints
from PIL import ImageDraw, Image, ImageFont # Used to draw the image
from gwendolyn.utils import encode_id
class Hangman():
"""
Controls hangman commands and game logic.
*Methods*
---------
start(ctx: SlashContext)
stop(ctx: SlashContext)
guess(message: discord.message, user: str, guess: str)
"""
def __init__(self, bot):
"""
Initialize the class.
*Attributes*
------------
draw: DrawHangman
The DrawHangman used to draw the hangman image.
API_url: str
The url to get the words from.
APIPARAMS: dict
The parameters to pass to every api call.
"""
self.bot = bot
self._draw = DrawHangman(bot)
self._API_url = "https://api.wordnik.com/v4/words.json/randomWords?" # pylint: disable=invalid-name
api_key = self.bot.credentials["wordnik_key"]
self._APIPARAMS = { # pylint: disable=invalid-name
"hasDictionaryDef": True,
"minCorpusCount": 5000,
"maxCorpusCount": -1,
"minDictionaryCount": 1,
"maxDictionaryCount": -1,
"minLength": 3,
"maxLength": 11,
"limit": 1,
"api_key": api_key
}
async def start(self, ctx: SlashContext):
"""
Start a game of hangman.
*Parameters*
------------
ctx: SlashContext
The context of the command.
"""
await self.bot.defer(ctx)
word = "-"
while "-" in word or "." in word:
response = requests.get(self._API_url, params=self._APIPARAMS)
word = list(response.json()[0]["word"].upper())
self.bot.log("Found the word \""+"".join(word)+"\"")
guessed = [False] * len(word)
game_id = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
remaining_letters = list(string.ascii_uppercase)
self._draw.draw_image(game_id, 0, word, guessed, [])
send_message = f"{ctx.author.display_name} started a game of hangman."
self.bot.log("Game started")
await ctx.send(send_message)
boards_path = "gwendolyn/resources/games/hangman_boards/"
file_path = f"{boards_path}hangman_board{game_id}.png"
image_message = await ctx.channel.send(
file=discord.File(file_path)
)
blank_message_one = await ctx.channel.send("_ _")
blank_message_two = await ctx.channel.send("_ _")
buttons = []
for letter in remaining_letters:
custom_id = encode_id([
"hangman",
"guess",
str(ctx.author.id),
letter,
"".join(word),
"",
game_id,
str(image_message.id),
str(blank_message_one.id),
str(blank_message_two.id)
])
buttons.append(create_button(
style=ButtonStyle.blue,
label=letter,
custom_id=custom_id
))
custom_id = encode_id([
"hangman",
"end",
str(ctx.author.id),
game_id,
str(image_message.id),
str(blank_message_one.id),
str(blank_message_two.id)
])
buttons.append(create_button(
style=ButtonStyle.red,
label="End game",
custom_id=custom_id
))
action_row_lists = []
for i in range(((len(buttons)-1)//20)+1):
action_rows = []
available_buttons = buttons[(i*20):(min(len(buttons),i*20+20))]
for x in range(((len(available_buttons)-1)//4)+1):
row_buttons = available_buttons[
(x*4):(min(len(available_buttons),x*4+4))
]
action_rows.append(create_actionrow(*row_buttons))
action_row_lists.append(action_rows)
await blank_message_one.edit(components=action_row_lists[0])
await blank_message_two.edit(components=action_row_lists[1])
async def stop(self, ctx: ComponentContext, game_id: str,
*messages: list[str]):
"""
Stop the game of hangman.
*Parameters*
------------
ctx: SlashContext
The context of the command.
"""
for msg_id in messages:
msg = await ctx.channel.fetch_message(msg_id)
await msg.delete()
self.bot.log("Deleting old messages")
await ctx.channel.send("Hangman game stopped")
boards_path = "gwendolyn/resources/games/hangman_boards/"
file_path = f"{boards_path}hangman_board{game_id}.png"
os.remove(file_path)
async def guess(self, ctx: ComponentContext, guess: str, word: str,
guessed_letters: str, game_id: str, *messages: list[str]):
"""
Guess a letter.
*Parameters*
------------
message: discord.Message
The message that the reaction was placed on.
user: str
The id of the user.
guess: str
The guess.
"""
for msg_id in messages:
msg = await ctx.channel.fetch_message(msg_id)
await msg.delete()
misses = 0
guessed_letters += guess
guessed = [False for i in range(len(word))]
for guessed_letter in guessed_letters:
correct_guess = 0
for i, letter in enumerate(word):
if guessed_letter == letter:
correct_guess += 1
guessed[i] = True
if correct_guess == 0:
misses += 1
remaining_letters = list(string.ascii_uppercase)
for letter in guessed_letters:
remaining_letters.remove(letter)
if correct_guess == 1:
send_message = "Guessed {}. There was 1 {} in the word."
send_message = send_message.format(guess, guess)
else:
send_message = "Guessed {}. There were {} {}s in the word."
send_message = send_message.format(guess, correct_guess, guess)
self._draw.draw_image(game_id, misses, word, guessed, guessed_letters)
if misses == 6:
send_message += self.bot.long_strings["Hangman lost game"]
remaining_letters = []
elif all(guessed):
self.bot.money.addMoney(f"#{ctx.author_id}", 15)
send_message += self.bot.long_strings["Hangman guessed word"]
remaining_letters = []
if remaining_letters != []:
await ctx.channel.send(send_message)
boards_path = "gwendolyn/resources/games/hangman_boards/"
file_path = f"{boards_path}hangman_board{game_id}.png"
image_message = await ctx.channel.send(
file=discord.File(file_path)
)
blank_message_one = await ctx.channel.send("_ _")
blank_message_two = await ctx.channel.send("_ _")
buttons = []
for letter in list(string.ascii_uppercase):
custom_id = encode_id([
"hangman",
"guess",
str(ctx.author.id),
letter,
word,
guessed_letters,
game_id,
str(image_message.id),
str(blank_message_one.id),
str(blank_message_two.id)
])
buttons.append(create_button(
style=ButtonStyle.blue,
label=letter,
custom_id=custom_id,
disabled=(letter not in remaining_letters)
))
custom_id = encode_id([
"hangman",
"end",
str(ctx.author.id),
game_id,
str(image_message.id),
str(blank_message_one.id),
str(blank_message_two.id)
])
buttons.append(create_button(
style=ButtonStyle.red,
label="End game",
custom_id=custom_id
))
action_row_lists = []
for i in range(((len(buttons)-1)//20)+1):
action_rows = []
available_buttons = buttons[(i*20):(min(len(buttons),i*20+20))]
for x in range(((len(available_buttons)-1)//4)+1):
row_buttons = available_buttons[
(x*4):(min(len(available_buttons),x*4+4))
]
action_rows.append(create_actionrow(*row_buttons))
action_row_lists.append(action_rows)
await blank_message_one.edit(components=action_row_lists[0])
await blank_message_two.edit(components=action_row_lists[1])
else:
boards_path = "gwendolyn/resources/games/hangman_boards/"
file_path = f"{boards_path}hangman_board{game_id}.png"
await ctx.channel.send(send_message, file=discord.File(file_path))
os.remove(file_path)
class DrawHangman():
"""
Draws the image of the hangman game.
*Methods*
---------
draw_image(channel: str)
"""
def __init__(self, bot):
"""
Initialize the class.
*Attributes*
------------
CIRCLESIZE
LINEWIDTH
BODYSIZE
LIMBSIZE
ARMPOSITION
MANX, MANY
LETTERLINELENGTH
LETTERLINEDISTANCE
GALLOWX, GALLOWY
PHI
FONT
SMALLFONT
"""
self._bot = bot
# pylint: disable=invalid-name
self._CIRCLESIZE = 120
self._LINEWIDTH = 12
self._BODYSIZE = 210
self._LIMBSIZE = 60
self._ARMPOSITION = 60
self._MANX = (self._LIMBSIZE*2)
self._MANY = (self._CIRCLESIZE+self._BODYSIZE+self._LIMBSIZE)
MANPADDING = self._LINEWIDTH*4
self._MANX += MANPADDING
self._MANY += MANPADDING
self._LETTERLINELENGTH = 90
self._LETTERLINEDISTANCE = 30
self._GALLOWX, self._GALLOWY = 360, 600
self._PHI = 1-(1 / ((1 + 5 ** 0.5) / 2))
LETTERSIZE = 75 # Wrong guesses letter size
WORDSIZE = 70 # Correct guesses letter size
FONTPATH = "gwendolyn/resources/fonts/comic-sans-bold.ttf"
self._FONT = ImageFont.truetype(FONTPATH, LETTERSIZE)
self._SMALLFONT = ImageFont.truetype(FONTPATH, WORDSIZE)
# pylint: enable=invalid-name
def _deviate(self, pre_deviance: int, pre_deviance_accuracy: int,
position_change: float, maxmin: int,
max_acceleration: float):
random_deviance = random.uniform(-position_change, position_change)
deviance_accuracy = pre_deviance_accuracy + random_deviance
if deviance_accuracy > maxmin * max_acceleration:
deviance_accuracy = maxmin * max_acceleration
elif deviance_accuracy < -maxmin * max_acceleration:
deviance_accuracy = -maxmin * max_acceleration
deviance = pre_deviance + deviance_accuracy
if deviance > maxmin:
deviance = maxmin
elif deviance < -maxmin:
deviance = -maxmin
return deviance, deviance_accuracy
def _bad_circle(self):
circle_padding = (self._LINEWIDTH*3)
image_width = self._CIRCLESIZE+circle_padding
image_size = (image_width, image_width)
background = Image.new("RGBA", image_size, color=(0, 0, 0, 0))
drawer = ImageDraw.Draw(background, "RGBA")
middle = (self._CIRCLESIZE+(self._LINEWIDTH*3))/2
deviance_x = 0
deviance_y = 0
deviance_accuracy_x = 0
deviance_accuracy_y = 0
start = random.randint(-100, -80)
degrees_amount = 360 + random.randint(-10, 30)
for degree in range(degrees_amount):
deviance_x, deviance_accuracy_x = self._deviate(
deviance_x,
deviance_accuracy_x,
self._LINEWIDTH/100,
self._LINEWIDTH,
0.03
)
deviance_y, deviance_accuracy_y = self._deviate(
deviance_y,
deviance_accuracy_y,
self._LINEWIDTH/100,
self._LINEWIDTH,
0.03
)
radians = math.radians(degree+start)
circle_x = (math.cos(radians) * (self._CIRCLESIZE/2))
circle_y = (math.sin(radians) * (self._CIRCLESIZE/2))
position_x = middle + circle_x - (self._LINEWIDTH/2) + deviance_x
position_y = middle + circle_y - (self._LINEWIDTH/2) + deviance_y
circle_position = [
(position_x, position_y),
(position_x+self._LINEWIDTH, position_y+self._LINEWIDTH)
]
drawer.ellipse(circle_position, fill=(0, 0, 0, 255))
return background
def _bad_line(self, length: int, rotated: bool = False):
if rotated:
width, height = length+self._LINEWIDTH*3, self._LINEWIDTH*3
else:
width, height = self._LINEWIDTH*3, length+self._LINEWIDTH*3
background = Image.new("RGBA", (width, height), color=(0, 0, 0, 0))
drawer = ImageDraw.Draw(background, "RGBA")
possible_deviance = int(self._LINEWIDTH/3)
deviance_x = random.randint(-possible_deviance, possible_deviance)
deviance_y = 0
deviance_accuracy_x = 0
deviance_accuracy_y = 0
for pixel in range(length):
deviance_x, deviance_accuracy_x = self._deviate(
deviance_x,
deviance_accuracy_x,
self._LINEWIDTH/1000,
self._LINEWIDTH,
0.004
)
deviance_y, deviance_accuracy_y = self._deviate(
deviance_y,
deviance_accuracy_y,
self._LINEWIDTH/1000,
self._LINEWIDTH,
0.004
)
if rotated:
position_x = self._LINEWIDTH + pixel + deviance_x
position_y = self._LINEWIDTH + deviance_y
else:
position_x = self._LINEWIDTH + deviance_x
position_y = self._LINEWIDTH + pixel + deviance_y
circle_position = [
(position_x, position_y),
(position_x+self._LINEWIDTH, position_y+self._LINEWIDTH)
]
drawer.ellipse(circle_position, fill=(0, 0, 0, 255))
return background
def _draw_man(self, misses: int, seed: str):
random.seed(seed)
man_size = (self._MANX, self._MANY)
background = Image.new("RGBA", man_size, color=(0, 0, 0, 0))
if misses >= 1:
head = self._bad_circle()
paste_x = (self._MANX-(self._CIRCLESIZE+(self._LINEWIDTH*3)))//2
paste_position = (paste_x, 0)
background.paste(head, paste_position, head)
if misses >= 2:
body = self._bad_line(self._BODYSIZE)
paste_x = (self._MANX-(self._LINEWIDTH*3))//2
paste_position = (paste_x, self._CIRCLESIZE)
background.paste(body, paste_position, body)
if misses >= 3:
limbs = random.sample(["rl", "ll", "ra", "la"], min(misses-2, 4))
else:
limbs = []
random.seed(seed)
for limb in limbs:
limb_drawing = self._bad_line(self._LIMBSIZE, True)
x_position = (self._MANX-(self._LINEWIDTH*3))//2
if limb[1] == "a":
rotation = random.randint(-45, 45)
shift = math.sin(math.radians(rotation))
line_length = self._LIMBSIZE+(self._LINEWIDTH*3)
compensation = int(shift*line_length)
limb_drawing = limb_drawing.rotate(rotation, expand=1)
y_position = self._CIRCLESIZE + self._ARMPOSITION
if limb == "ra":
compensation = min(-compensation, 0)
else:
x_position -= self._LIMBSIZE
compensation = min(compensation, 0)
y_position += compensation
else:
rotation = random.randint(-15, 15)
y_position = self._CIRCLESIZE+self._BODYSIZE-self._LINEWIDTH
if limb == "rl":
limb_drawing = limb_drawing.rotate(rotation-45, expand=1)
else:
x_position += -limb_drawing.size[0]+self._LINEWIDTH*3
limb_drawing = limb_drawing.rotate(rotation+45, expand=1)
paste_position = (x_position, y_position)
background.paste(limb_drawing, paste_position, limb_drawing)
return background
def _bad_text(self, text: str, big: bool, color: tuple = (0, 0, 0, 255)):
if big:
font = self._FONT
else:
font = self._SMALLFONT
width, height = font.getsize(text)
img = Image.new("RGBA", (width, height), color=(0, 0, 0, 0))
drawer = ImageDraw.Draw(img, "RGBA")
drawer.text((0, 0), text, font=font, fill=color)
return img
def _draw_gallows(self):
gallow_size = (self._GALLOWX, self._GALLOWY)
background = Image.new("RGBA", gallow_size, color=(0, 0, 0, 0))
bottom_line = self._bad_line(int(self._GALLOWX * 0.75), True)
bottom_line_x = int(self._GALLOWX * 0.125)
bottom_line_y = self._GALLOWY-(self._LINEWIDTH*4)
paste_position = (bottom_line_x, bottom_line_y)
background.paste(bottom_line, paste_position, bottom_line)
line_two = self._bad_line(self._GALLOWY-self._LINEWIDTH*6)
line_two_x = int(self._GALLOWX*(0.75*self._PHI))
line_two_y = self._LINEWIDTH*2
paste_position = (line_two_x, line_two_y)
background.paste(line_two, paste_position, line_two)
top_line = self._bad_line(int(self._GALLOWY*0.30), True)
paste_x = int(self._GALLOWX*(0.75*self._PHI))-self._LINEWIDTH
paste_position = (paste_x, self._LINEWIDTH*3)
background.paste(top_line, paste_position, top_line)
last_line = self._bad_line(int(self._GALLOWY*0.125))
paste_x += int(self._GALLOWY*0.30)
background.paste(last_line, (paste_x, self._LINEWIDTH*3), last_line)
return background
def _draw_letter_lines(self, word: str, guessed: list, misses: int):
letter_width = self._LETTERLINELENGTH+self._LETTERLINEDISTANCE
image_width = letter_width*len(word)
image_size = (image_width, self._LETTERLINELENGTH+self._LINEWIDTH*3)
letter_lines = Image.new("RGBA", image_size, color=(0, 0, 0, 0))
for i, letter in enumerate(word):
line = self._bad_line(self._LETTERLINELENGTH, True)
paste_x = i*(self._LETTERLINELENGTH+self._LETTERLINEDISTANCE)
paste_position = (paste_x, self._LETTERLINELENGTH)
letter_lines.paste(line, paste_position, line)
if guessed[i]:
letter_drawing = self._bad_text(letter, True)
letter_width = self._FONT.getsize(letter)[0]
letter_x = i*(self._LETTERLINELENGTH+self._LETTERLINEDISTANCE)
letter_x -= (letter_width//2)
letter_x += (self._LETTERLINELENGTH//2)+(self._LINEWIDTH*2)
letter_lines.paste(
letter_drawing,
(letter_x, 0),
letter_drawing
)
elif misses == 6:
letter_drawing = self._bad_text(letter, True, (242, 66, 54))
letter_width = self._FONT.getsize(letter)[0]
letter_x = i*(self._LETTERLINELENGTH+self._LETTERLINEDISTANCE)
letter_x -= (letter_width//2)
letter_x += (self._LETTERLINELENGTH//2)+(self._LINEWIDTH*2)
letter_lines.paste(
letter_drawing,
(letter_x, 0),
letter_drawing
)
return letter_lines
def _shortest_dist(self, positions: list, new_position: tuple):
shortest_dist = math.inf
for i, j in positions:
x_distance = abs(i-new_position[0])
y_distance = abs(j-new_position[1])
dist = math.sqrt(x_distance**2+y_distance**2)
if shortest_dist > dist:
shortest_dist = dist
return shortest_dist
def _draw_misses(self, guesses: list, word: str):
background = Image.new("RGBA", (600, 400), color=(0, 0, 0, 0))
pos = []
for guess in guesses:
if guess not in word:
placed = False
while not placed:
letter = self._bad_text(guess, True)
w, h = self._FONT.getsize(guess)
x = random.randint(0, 600-w)
y = random.randint(0, 400-h)
if self._shortest_dist(pos, (x, y)) > 70:
pos.append((x, y))
background.paste(letter, (x, y), letter)
placed = True
return background
def draw_image(self, game_id: str, misses: int, word: str,
guessed: list[bool], guessed_letters: str):
"""
Draw a hangman Image.
*Parameters*
------------
channel: str
The id of the channel the game is in.
"""
self._bot.log("Drawing hangman image")
random.seed(game_id)
background = Image.open("gwendolyn/resources/games/default_images/hangman.png")
gallow = self._draw_gallows()
man = self._draw_man(misses, game_id)
random.seed(game_id)
letter_line_parameters = [word, guessed, misses]
letter_lines = self._draw_letter_lines(*letter_line_parameters)
random.seed(game_id)
misses = self._draw_misses(list(guessed_letters), word)
background.paste(gallow, (100, 100), gallow)
background.paste(man, (300, 210), man)
background.paste(letter_lines, (120, 840), letter_lines)
background.paste(misses, (600, 150), misses)
misses_text = self._bad_text("MISSES", False)
misses_text_width = misses_text.size[0]
background.paste(misses_text, (850-misses_text_width//2, 50), misses_text)
boards_path = "gwendolyn/resources/games/hangman_boards/"
image_path = f"{boards_path}hangman_board{game_id}.png"
background.save(image_path)

642
gwendolyn/funcs/games/hex.py
View File

@ -1,642 +0,0 @@
import random
import copy
import math
import discord
from PIL import Image, ImageDraw, ImageFont
class HexGame():
def __init__(self, bot):
self.bot = bot
self.draw = DrawHex(bot)
self.BOARDWIDTH = 11
self.ALLPOSITIONS = [(i,j) for i in range(11) for j in range(11)]
self.ALLSET = set(self.ALLPOSITIONS)
self.EMPTYDIJKSTRA = {}
for position in self.ALLPOSITIONS:
self.EMPTYDIJKSTRA[position] = math.inf # an impossibly high number
self.HEXDIRECTIONS = [(0,1),(-1,1),(-1,0),(0,-1),(1,-1),(1,0)]
async def surrender(self, ctx):
channel = str(ctx.channel_id)
game = self.bot.database["hex games"].find_one({"_id":channel})
user = f"#{ctx.author.id}"
players = game["players"]
if user not in players:
await ctx.send("You can't surrender when you're not a player.")
else:
opponent = (players.index(user) + 1) % 2
opponent_name = self.bot.database_funcs.get_name(players[opponent])
self.bot.database["hex games"].update_one({"_id":channel},{"$set":{"winner":opponent + 1}})
await ctx.send(f"{ctx.author.display_name} surrendered")
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "r") as f:
old_image = await ctx.channel.fetch_message(int(f.read()))
if old_image is not None:
await old_image.delete()
else:
self.bot.log("The old image was already deleted")
self.bot.log("Sending the image")
file_path = f"gwendolyn/resources/games/hex_boards/board{channel}.png"
old_image = await ctx.channel.send(file = discord.File(file_path))
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "w") as f:
f.write(str(old_image.id))
self.bot.database["hex games"].delete_one({"_id":channel})
# Swap
async def swap(self, ctx):
channel = str(ctx.channel_id)
game = self.bot.database["hex games"].find_one({"_id":channel})
user = f"#{ctx.author.id}"
if game is None:
await ctx.send("You can't swap nothing")
elif user not in game["players"]:
await ctx.send("You're not in the game")
elif len(game["gameHistory"]) != 1: # Only after the first move
await ctx.send("You can only swap as the second player after the very first move.")
elif user != game["players"][game["turn"]-1]:
await ctx.send("You can only swap after your opponent has placed their piece")
else:
self.bot.database["hex games"].update_one({"_id":channel},
{"$set":{"players":game["players"][::-1]}}) # Swaps their player-number
# Swaps the color of the hexes on the board drawing:
self.draw.drawSwap(channel)
opponent = game["players"][::-1][game["turn"]-1]
gwendolyn_turn = (opponent == f"#{self.bot.user.id}")
opponent_name = self.bot.database_funcs.get_name(opponent)
await ctx.send(f"The color of the players were swapped. It is now {opponent_name}'s turn")
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "r") as f:
old_image = await ctx.channel.fetch_message(int(f.read()))
if old_image is not None:
await old_image.delete()
else:
self.bot.log("The old image was already deleted")
self.bot.log("Sending the image")
file_path = f"gwendolyn/resources/games/hex_boards/board{channel}.png"
old_image = await ctx.channel.send(file = discord.File(file_path))
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "w") as f:
f.write(str(old_image.id))
if gwendolyn_turn:
await self.hexAI(ctx)
# Starts the game
async def start(self, ctx, opponent):
await self.bot.defer(ctx)
user = f"#{ctx.author.id}"
channel = str(ctx.channel_id)
game = self.bot.database["hex games"].find_one({"_id":channel})
started_game = False
can_start = True
if game != None:
send_message = "There's already a hex game going on in this channel"
log_message = "There was already a game going on"
can_start = False
else:
if type(opponent) == int:
# Opponent is Gwendolyn
if opponent in range(1, 6):
opponent_name = "Gwendolyn"
difficulty = int(opponent)
difficulty_text = f" with difficulty {difficulty}"
opponent = f"#{self.bot.user.id}"
else:
send_message = "Difficulty doesn't exist"
log_message = "They tried to play against a difficulty that doesn't exist"
can_start = False
elif type(opponent) == discord.member.Member:
if opponent.bot:
# User has challenged a bot
if opponent == self.bot.user:
# It was Gwendolyn
opponent_name = "Gwendolyn"
difficulty = 2
difficulty_text = f" with difficulty {difficulty}"
opponent = f"#{self.bot.user.id}"
else:
send_message = "You can't challenge a bot!"
log_message = "They tried to challenge a bot"
can_start = False
else:
# Opponent is another player
if ctx.author != opponent:
opponent_name = opponent.display_name
opponent = f"#{opponent.id}"
difficulty = 5
difficulty_text = ""
else:
send_message = "You can't play against yourself"
log_message = "They tried to play against themself"
can_start = False
else:
can_start = False
log_message = f"Opponent was neither int or member. It was {type(opponent)}"
send_message = "Something went wrong"
if can_start:
# board is 11x11
board = [[0 for i in range(self.BOARDWIDTH)] for j in range(self.BOARDWIDTH)]
players = [user, opponent]
random.shuffle(players) # random starting player
gameHistory = []
new_game = {"_id":channel,"board":board, "winner":0,
"players":players, "turn":1, "difficulty":difficulty, "gameHistory":gameHistory}
self.bot.database["hex games"].insert_one(new_game)
# draw the board
self.draw.drawBoard(channel)
gwendolyn_turn = (players[0] == f"#{self.bot.user.id}")
started_game = True
turn_name = self.bot.database_funcs.get_name(players[0])
send_message = f"Started Hex game against {opponent_name}{difficulty_text}. It's {turn_name}'s turn"
log_message = "Game started"
await ctx.send(send_message)
self.bot.log(log_message)
if started_game:
file_path = f"gwendolyn/resources/games/hex_boards/board{ctx.channel_id}.png"
new_image = await ctx.channel.send(file = discord.File(file_path))
with open(f"gwendolyn/resources/games/old_images/hex{ctx.channel_id}", "w") as f:
f.write(str(new_image.id))
if gwendolyn_turn:
await self.hexAI(ctx)
# Places a piece at the given location and checks things afterwards
async def placeHex(self, ctx, position : str, user):
channel = str(ctx.channel_id)
game = self.bot.database["hex games"].find_one({"_id":channel})
placed_piece = False
if game == None:
send_message = "There's no game in this channel"
self.bot.log("There was no game going on")
elif not (position[0].isalpha() and position[1:].isnumeric() and len(position) in [2, 3]):
send_message = "The position must be a letter followed by a number."
self.bot.log(f"The position was not valid, {position}")
else:
players = game["players"]
if user not in players:
send_message = f"You can't place when you're not in the game. The game's players are: {self.bot.database_funcs.get_name(game['players'][0])} and {self.bot.database_funcs.get_name(game['players'][1])}."
self.bot.log("They aren't in the game")
elif players[game["turn"]-1] != user:
send_message = "It's not your turn"
self.bot.log("It wasn't their turn")
else:
player = game["turn"]
turn = game["turn"]
board = game["board"]
self.bot.log("Placing a piece on the board with placeHex()")
# Places on board
board = self.placeOnHexBoard(board,player,position)
if board is None:
self.bot.log("It was an invalid position")
send_message = ("That's an invalid position. You must place your piece on an empty field.")
else:
# If the move is valid:
self.bot.database["hex games"].update_one({"_id":channel},{"$set":{"board":board}})
turn = (turn % 2) + 1
self.bot.database["hex games"].update_one({"_id":channel},{"$set":{"turn":turn}})
# Checking for a win
self.bot.log("Checking for win")
winner = self.evaluateBoard(game["board"])[1]
if winner == 0: # Continue with the game.
game_won = False
send_message = self.bot.database_funcs.get_name(game["players"][player-1])+" placed at "+position.upper()+". It's now "+self.bot.database_funcs.get_name(game["players"][turn-1])+"'s turn."# The score is "+str(score)
else: # Congratulations!
game_won = True
self.bot.database["hex games"].update_one({"_id":channel},{"$set":{"winner":winner}})
send_message = self.bot.database_funcs.get_name(game["players"][player-1])+" placed at "+position.upper()+" and won!"
if game["players"][winner-1] != f"#{self.bot.user.id}":
win_amount = game["difficulty"]*10
send_message += " Adding "+str(win_amount)+" GwendoBucks to their account."
self.bot.database["hex games"].update_one({"_id":channel},
{"$push":{"gameHistory":(int(position[1])-1, ord(position[0])-97)}})
# Is it now Gwendolyn's turn?
gwendolyn_turn = False
if game["players"][turn-1] == f"#{self.bot.user.id}":
self.bot.log("It's Gwendolyn's turn")
gwendolyn_turn = True
placed_piece = True
if user == f"#{self.bot.user.id}":
await ctx.channel.send(send_message)
else:
await ctx.send(send_message)
if placed_piece:
# Update the board
self.draw.drawHexPlacement(channel,player, position)
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "r") as f:
old_image = await ctx.channel.fetch_message(int(f.read()))
if old_image is not None:
await old_image.delete()
else:
self.bot.log("The old image was already deleted")
self.bot.log("Sending the image")
file_path = f"gwendolyn/resources/games/hex_boards/board{channel}.png"
old_image = await ctx.channel.send(file = discord.File(file_path))
if game_won:
self.bot.log("Dealing with the winning player")
game = self.bot.database["hex games"].find_one({"_id":channel})
winner = game["winner"]
if game["players"][winner-1] != f"#{self.bot.user.id}":
winnings = game["difficulty"]*10
self.bot.money.addMoney(game["players"][winner-1].lower(),winnings)
self.bot.database["hex games"].delete_one({"_id":channel})
else:
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "w") as f:
f.write(str(old_image.id))
if gwendolyn_turn:
await self.hexAI(ctx)
# Returns a board where the placement has ocurred
def placeOnHexBoard(self, board,player,position):
# Translates the position
position = position.lower()
# Error handling
column = ord(position[0]) - 97 # ord() translates from letter to number
row = int(position[1:]) - 1
if column not in range(self.BOARDWIDTH) or row not in range(self.BOARDWIDTH):
self.bot.log("Position out of bounds")
return None
# Place at the position
if board[row][column] == 0:
board[row][column] = player
return board
else:
self.bot.log("Cannot place on existing piece")
return None
# After your move, you have the option to undo get your turn back #TimeTravel
async def undo(self, ctx):
channel = str(ctx.channel_id)
user = f"#{ctx.author.id}"
undid = False
game = self.bot.database["hex games"].find_one({"_id":channel})
if user not in game["players"]:
send_message = "You're not a player in the game"
elif len(game["gameHistory"]) == 0:
send_message = "You can't undo nothing"
elif user != game["players"][(game["turn"] % 2)]: # If it's not your turn
send_message = "It's not your turn"
else:
turn = game["turn"]
self.bot.log("Undoing {}'s last move".format(self.bot.database_funcs.get_name(user)))
lastMove = game["gameHistory"].pop()
game["board"][lastMove[0]][lastMove[1]] = 0
self.bot.database["hex games"].update_one({"_id":channel},
{"$set":{"board":game["board"]}})
self.bot.database["hex games"].update_one({"_id":channel},
{"$set":{"turn":turn%2 + 1}})
# Update the board
self.draw.drawHexPlacement(channel,0,"abcdefghijk"[lastMove[1]]+str(lastMove[0]+1)) # The zero makes the hex disappear
send_message = f"You undid your last move at {lastMove}"
undid = True
await ctx.send(send_message)
if undid:
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "r") as f:
old_image = await ctx.channel.fetch_message(int(f.read()))
if old_image is not None:
await old_image.delete()
else:
self.bot.log("The old image was already deleted")
self.bot.log("Sending the image")
file_path = f"gwendolyn/resources/games/hex_boards/board{channel}.png"
old_image = await ctx.channel.send(file = discord.File(file_path))
with open(f"gwendolyn/resources/games/old_images/hex{channel}", "w") as f:
f.write(str(old_image.id))
# Plays as the AI
async def hexAI(self, ctx):
channel = str(ctx.channel_id)
self.bot.log("Figuring out best move")
game = self.bot.database["hex games"].find_one({"_id":channel})
board = game["board"]
if len(game["gameHistory"]):
lastMove = game["gameHistory"][-1]
else:
lastMove = (5,5)
# These moves are the last move +- 2.
moves = [[(lastMove[0]+j-2,lastMove[1]+i-2) for i in range(5) if lastMove[1]+i-2 in range(11)] for j in range(5) if lastMove[0]+j-2 in range(11)]
moves = sum(moves,[])
movesCopy = moves.copy()
for move in movesCopy:
if board[move[0]][move[1]] != 0:
moves.remove(move)
chosenMove = random.choice(moves)
placement = "abcdefghijk"[chosenMove[1]]+str(chosenMove[0]+1)
self.bot.log(f"ChosenMove is {chosenMove} at {placement}")
await self.placeHex(ctx, placement, f"#{self.bot.user.id}")
def evaluateBoard(self, board):
scores = {1:0, 2:0}
winner = 0
# Here, I use Dijkstra's algorithm to evaluate the board, as proposed by this article: https://towardsdatascience.com/hex-creating-intelligent-adversaries-part-2-heuristics-dijkstras-algorithm-597e4dcacf93
for player in [1,2]:
Distance = copy.deepcopy(self.EMPTYDIJKSTRA)
# Initialize the starting hexes. For the blue player, this is the leftmost column. For the red player, this is the tom row.
for start in (self.ALLPOSITIONS[::11] if player == 2 else self.ALLPOSITIONS[:11]):
# An empty hex adds a of distance of 1. A hex of own color add distance 0. Opposite color adds infinite distance.
Distance[start] = 1 if (board[start[0]][start[1]] == 0) else 0 if (board[start[0]][start[1]] == player) else math.inf
visited = set() # Also called sptSet, short for "shortest path tree Set"
for _ in range(self.BOARDWIDTH**2): # We can at most check every 121 hexes
# Find the next un-visited hex, that has the lowest distance
remainingHexes = self.ALLSET.difference(visited)
A = [Distance[k] for k in remainingHexes] # Find the distance to each un-visited hex
u = list(remainingHexes)[A.index(min(A))] # Chooses the one with the lowest distance
# Find neighbors of the hex u
for di in self.HEXDIRECTIONS:
v = (u[0] + di[0] , u[1] + di[1]) # v is a neighbor of u
if v[0] in range(11) and v[1] in range(11) and v not in visited:
new_dist = Distance[u] + (1 if (board[v[0]][v[1]] == 0) else 0 if (board[v[0]][v[1]] == player) else math.inf)
Distance[v] = min(Distance[v], new_dist)
# After a hex has been visited, this is noted
visited.add(u)
#self.bot.log("Distance from player {}'s start to {} is {}".format(player,u,Distance[u]))
if u[player-1] == 10: # if the right coordinate of v is 10, it means we're at the goal
scores[player] = Distance[u] # A player's score is the shortest distance to goal. Which equals the number of remaining moves they need to win if unblocked by the opponent.
break
else:
self.bot.log("For some reason, no path to the goal was found. ")
if scores[player] == 0:
winner = player
break # We don't need to check the other player's score, if player1 won.
return scores[2]-scores[1], winner
def minimaxHex(self, board, depth, alpha, beta, maximizing_player):
# The depth is how many moves ahead the computer checks. This value is the difficulty.
if depth == 0 or 0 not in sum(board,[]):
score = self.evaluateBoard(board)[0]
return score
# if final depth is not reached, look another move ahead:
if maximizing_player: # red player predicts next move
maxEval = -math.inf
possiblePlaces = [i for i,v in enumerate(sum(board,[])) if v == 0]
#self.bot.log("Judging a red move at depth {}".format(depth))
for i in possiblePlaces:
test_board = copy.deepcopy(board)
test_board[i // self.BOARDWIDTH][i % self.BOARDWIDTH] = 1 # because maximizing_player is Red which is number 1
evaluation = self.minimaxHex(test_board,depth-1,alpha,beta,False)
maxEval = max(maxEval, evaluation)
alpha = max(alpha, evaluation)
if beta <= alpha:
#self.bot.log("Just pruned something!")
break
return maxEval
else: # blue player predicts next move
minEval = math.inf
possiblePlaces = [i for i,v in enumerate(sum(board,[])) if v == 0]
#self.bot.log("Judging a blue move at depth {}".format(depth))
for i in possiblePlaces:
test_board = copy.deepcopy(board)
test_board[i // self.BOARDWIDTH][i % self.BOARDWIDTH] = 2 # because minimizingPlayer is Blue which is number 2
evaluation = self.minimaxHex(test_board,depth-1,alpha,beta,True)
minEval = min(minEval, evaluation)
beta = min(beta, evaluation)
if beta <= alpha:
#self.bot.log("Just pruned something!")
break
return minEval
class DrawHex():
def __init__(self,bot):
self.bot = bot
# Defining all the variables
self.CANVASWIDTH = 2400
self.CANVASHEIGHT = 1800
self.SIDELENGTH = 75
# The offsets centers the board in the picture
self.XOFFSET = self.CANVASWIDTH/2 - 8*math.sqrt(3)*self.SIDELENGTH
# The offsets are the coordinates of the upperleft point in the
# upperleftmost hexagon
self.YOFFSET = self.CANVASHEIGHT/2 - 8*self.SIDELENGTH
# The whole width of one hexagon
self.HEXAGONWIDTH = math.sqrt(3) * self.SIDELENGTH
# The height difference between two layers
self.HEXAGONHEIGHT = 1.5 * self.SIDELENGTH
self.FONTSIZE = 45
self.TEXTCOLOR = (0,0,0)
self.FONT = ImageFont.truetype('gwendolyn/resources/fonts/futura-bold.ttf', self.FONTSIZE)
self.LINETHICKNESS = 15
self.HEXTHICKNESS = 6 # This is half the width of the background lining between every hex
self.XTHICKNESS = self.HEXTHICKNESS * math.cos(math.pi/6)
self.YTHICKNESS = self.HEXTHICKNESS * math.sin(math.pi/6)
self.BACKGROUNDCOLOR = (230,230,230)
self.BETWEENCOLOR = (231,231,231)
self.BLANKCOLOR = "lightgrey"
self.PIECECOLOR = {1:(237,41,57),2:(0,165,255),0:self.BLANKCOLOR} # player1 is red, player2 is blue
self.BOARDCOORDINATES = [ [(self.XOFFSET + self.HEXAGONWIDTH*(column + row/2),self.YOFFSET + self.HEXAGONHEIGHT*row) for column in range(11)] for row in range(11)] # These are the coordinates for the upperleft corner of every hex
self.COLHEXTHICKNESS = 4 # When placing a hex, it is a little bigger than the underlying hex in the background (4 < 6)
self.COLXTHICKNESS = self.COLHEXTHICKNESS * math.cos(math.pi/6)
self.COLYTHICKNESS = self.COLHEXTHICKNESS * math.sin(math.pi/6)
# The Name display things:
self.NAMESIZE = 60
self.NAMEFONT = ImageFont.truetype('gwendolyn/resources/fonts/futura-bold.ttf', self.NAMESIZE)
self.XNAME = {1:175, 2:self.CANVASWIDTH-100}
self.YNAME = {1:self.CANVASHEIGHT-150, 2:150}
self.NAMEHEXPADDING = 90
self.SMALLWIDTH = self.HEXAGONWIDTH * 0.6
self.SMALLSIDELENGTH = self.SIDELENGTH * 0.6
def drawBoard(self, channel):
self.bot.log("Drawing empty Hex board")
# Creates the empty image
im = Image.new('RGB', size=(self.CANVASWIDTH, self.CANVASHEIGHT),color = self.BACKGROUNDCOLOR)
# 'd' is a shortcut to drawing on the image
d = ImageDraw.Draw(im,"RGBA")
# Drawing all the hexagons
for column in self.BOARDCOORDINATES:
for startingPoint in column:
x = startingPoint[0]
y = startingPoint[1]
d.polygon([
(x, y),
(x+self.HEXAGONWIDTH/2, y-0.5*self.SIDELENGTH),
(x+self.HEXAGONWIDTH, y),
(x+self.HEXAGONWIDTH, y+self.SIDELENGTH),
(x+self.HEXAGONWIDTH/2, y+1.5*self.SIDELENGTH),
(x, y+self.SIDELENGTH),
],fill = self.BETWEENCOLOR)
d.polygon([
(x+self.XTHICKNESS, y + self.YTHICKNESS),
(x+self.HEXAGONWIDTH/2, y-0.5*self.SIDELENGTH + self.HEXTHICKNESS),
(x+self.HEXAGONWIDTH-self.XTHICKNESS, y + self.YTHICKNESS),
(x+self.HEXAGONWIDTH-self.XTHICKNESS, y+self.SIDELENGTH - self.YTHICKNESS),
(x+self.HEXAGONWIDTH/2, y+1.5*self.SIDELENGTH - self.HEXTHICKNESS),
(x+self.XTHICKNESS, y+self.SIDELENGTH - self.YTHICKNESS),
],fill = self.BLANKCOLOR)
# Draw color on the outside of the board
# Top line, red
d.line(sum((sum([(point[0],point[1],point[0]+self.HEXAGONWIDTH/2,point[1]-self.HEXAGONHEIGHT+self.SIDELENGTH) for point in self.BOARDCOORDINATES[0]],()),(self.BOARDCOORDINATES[0][10][0]+self.HEXAGONWIDTH*3/4,self.BOARDCOORDINATES[0][10][1]-self.SIDELENGTH/4)),()),
fill = self.PIECECOLOR[1],width = self.LINETHICKNESS)
# Bottom line, red
d.line(sum(((self.BOARDCOORDINATES[10][0][0]+self.HEXAGONWIDTH/4,self.BOARDCOORDINATES[10][0][1]+self.SIDELENGTH*5/4),sum([(point[0]+self.HEXAGONWIDTH/2,point[1]+self.HEXAGONHEIGHT,point[0]+self.HEXAGONWIDTH,point[1]+self.SIDELENGTH) for point in self.BOARDCOORDINATES[10]],())),()),
fill = self.PIECECOLOR[1],width = self.LINETHICKNESS)
# Left line, blue
d.line(sum((sum([(row[0][0],row[0][1],row[0][0],row[0][1]+self.SIDELENGTH) for row in self.BOARDCOORDINATES],()),(self.BOARDCOORDINATES[10][0][0]+self.HEXAGONWIDTH/4,self.BOARDCOORDINATES[10][0][1]+self.SIDELENGTH*5/4)),()),
fill = self.PIECECOLOR[2],width = self.LINETHICKNESS)
# Right line, blue
d.line(sum(((self.BOARDCOORDINATES[0][10][0]+self.HEXAGONWIDTH*3/4,self.BOARDCOORDINATES[0][10][1]-self.SIDELENGTH/4),sum([(row[10][0]+self.HEXAGONWIDTH,row[10][1],row[10][0]+self.HEXAGONWIDTH,row[10][1]+self.SIDELENGTH) for row in self.BOARDCOORDINATES],())),()),
fill = self.PIECECOLOR[2],width = self.LINETHICKNESS)
# Writes "abc..", "123.." on the columns and rows
for i in range(11):
# Top letters
d.text( (self.XOFFSET + self.HEXAGONWIDTH*i, self.YOFFSET-66) , "ABCDEFGHIJK"[i], font=self.FONT, fill=self.TEXTCOLOR)
# Bottom letters
d.text( (self.XOFFSET + self.HEXAGONWIDTH*(i+11.5/2), self.YOFFSET - 15 + 11*self.HEXAGONHEIGHT) , "ABCDEFGHIJK"[i], font=self.FONT, fill=self.TEXTCOLOR)
# Left numbers
d.multiline_text( (self.XOFFSET + self.HEXAGONWIDTH*i/2 - 72 -4*(i>8), self.YOFFSET + 18 + i*self.HEXAGONHEIGHT) , str(i+1), font=self.FONT, fill=self.TEXTCOLOR, align="right")
# Right numbers
d.text( (self.XOFFSET + self.HEXAGONWIDTH*(i/2+11) + 30 , self.YOFFSET + 6 + i*self.HEXAGONHEIGHT) , str(i+1), font=self.FONT, fill=self.TEXTCOLOR)
# Write player names and color
game = self.bot.database["hex games"].find_one({"_id":channel})
for p in [1,2]:
playername = self.bot.database_funcs.get_name(game["players"][p-1])
# Draw name
x = self.XNAME[p]
x -= self.NAMEFONT.getsize(playername)[0] if p==2 else 0 # player2's name is right-aligned
y = self.YNAME[p]
d.text((x,y),playername, font=self.NAMEFONT, fill = self.TEXTCOLOR)
# Draw a half-size Hexagon to indicate the player's color
x -= self.NAMEHEXPADDING # To the left of both names
d.polygon([
(x, y),
(x+self.SMALLWIDTH/2, y-self.SMALLSIDELENGTH/2),
(x+self.SMALLWIDTH, y),
(x+self.SMALLWIDTH, y+self.SMALLSIDELENGTH),
(x+self.SMALLWIDTH/2, y+self.SMALLSIDELENGTH*3/2),
(x, y+self.SMALLSIDELENGTH),
],fill = self.PIECECOLOR[p])
im.save("gwendolyn/resources/games/hex_boards/board"+channel+".png")
def drawHexPlacement(self, channel,player,position):
FILEPATH = "gwendolyn/resources/games/hex_boards/board"+channel+".png"
self.bot.log(f"Drawing a newly placed hex. Filename: board{channel}.png")
# Translates position
# We don't need to error-check, because the position is already checked in placeOnHexBoard()
position = position.lower()
column = ord(position[0])-97 # ord() translates from letter to number
row = int(position[1:])-1
# Find the coordinates for the filled hex drawing
hex_coords = [
(self.BOARDCOORDINATES[row][column][0]+self.COLXTHICKNESS, self.BOARDCOORDINATES[row][column][1] + self.COLYTHICKNESS),
(self.BOARDCOORDINATES[row][column][0]+self.HEXAGONWIDTH/2, self.BOARDCOORDINATES[row][column][1]-0.5*self.SIDELENGTH + self.COLHEXTHICKNESS),
(self.BOARDCOORDINATES[row][column][0]+self.HEXAGONWIDTH-self.COLXTHICKNESS, self.BOARDCOORDINATES[row][column][1] + self.COLYTHICKNESS),
(self.BOARDCOORDINATES[row][column][0]+self.HEXAGONWIDTH-self.COLXTHICKNESS, self.BOARDCOORDINATES[row][column][1]+self.SIDELENGTH - self.COLYTHICKNESS),
(self.BOARDCOORDINATES[row][column][0]+self.HEXAGONWIDTH/2, self.BOARDCOORDINATES[row][column][1]+1.5*self.SIDELENGTH - self.COLHEXTHICKNESS),
(self.BOARDCOORDINATES[row][column][0]+self.COLXTHICKNESS, self.BOARDCOORDINATES[row][column][1]+self.SIDELENGTH - self.COLYTHICKNESS),
]
# Opens the image
try:
with Image.open(FILEPATH) as im:
d = ImageDraw.Draw(im,"RGBA")
# Draws the hex piece
d.polygon(hex_coords,fill = self.PIECECOLOR[player], outline = self.BETWEENCOLOR)
# Save
im.save(FILEPATH)
except:
self.bot.log("Error drawing new hex on board")
def drawSwap(self, channel):
FILEPATH = "gwendolyn/resources/games/hex_boards/board"+channel+".png"
game = self.bot.database["hex games"].find_one({"_id":channel})
# Opens the image
try:
with Image.open(FILEPATH) as im:
d = ImageDraw.Draw(im,"RGBA")
# Write player names and color
for p in [1,2]:
playername = self.bot.database_funcs.get_name(game["players"][p%2])
x = self.XNAME[p]
x -= self.NAMEFONT.getsize(playername)[0] if p==2 else 0 # player2's name is right-aligned
y = self.YNAME[p]
# Draw a half-size Hexagon to indicate the player's color
x -= self.NAMEHEXPADDING # To the left of both names
d.polygon([
(x, y),
(x+self.SMALLWIDTH/2, y-self.SMALLSIDELENGTH/2),
(x+self.SMALLWIDTH, y),
(x+self.SMALLWIDTH, y+self.SMALLSIDELENGTH),
(x+self.SMALLWIDTH/2, y+self.SMALLSIDELENGTH*3/2),
(x, y+self.SMALLSIDELENGTH),
],fill = self.PIECECOLOR[p % 2 + 1])
# Save
im.save(FILEPATH)
except:
self.bot.log("Error drawing swap")

286
gwendolyn/funcs/games/invest.py
View File

@ -1,286 +0,0 @@
"""
Contains functions relating to invest commands.
*Classes*
---------
Invest
Contains all the code for the invest commands.
"""
import discord # Used for embeds
from discord_slash.context import SlashContext # Used for type hints
class Invest():
"""
Contains all the invest functions.
*Methods*
---------
getPrice(symbol: str) -> int
getPortfolio(user: str) -> str
buyStock(user: str, stock: str: buyAmount: int) -> str
sellStock(user: str, stock: str, buyAmount: int) -> str
parseInvest(ctx: discord_slash.context.SlashContext,
parameters: str)
"""
def __init__(self, bot):
"""Initialize the class."""
self.bot = bot
def getPrice(self, symbol: str):
"""
Get the price of a stock.
*Parameters*
------------
symbol: str
The symbol of the stock to get the price of.
*Returns*
---------
price: int
The price of the stock.
"""
res = self.bot.finnhub_client.quote(symbol.upper())
if res == {}:
return 0
else:
return int(res["c"] * 100)
def getPortfolio(self, user: str):
"""
Get the stock portfolio of a user.
*Parameters*
------------
user: str
The id of the user to get the portfolio of.
*Returns*
---------
portfolio: str
The portfolio.
"""
investments_database = self.bot.database["investments"]
userInvestments = investments_database.find_one({"_id": user})
user_name = self.bot.database_funcs.get_name(user)
if userInvestments in [None, {}]:
return f"{user_name} does not have a stock portfolio."
else:
portfolio = f"**Stock portfolio for {user_name}**"
for key, value in list(userInvestments["investments"].items()):
purchaseValue = value["purchased for"]
stockPrice = self.getPrice(key)
valueAtPurchase = value["value at purchase"]
purchasedStock = value["purchased"]
valueChange = (stockPrice / valueAtPurchase)
currentValue = int(valueChange * purchasedStock)
portfolio += f"\n**{key}**: ___{currentValue} GwendoBucks___"
if purchaseValue != "?":
portfolio += f" (purchased for {purchaseValue})"
return portfolio
def buyStock(self, user: str, stock: str, buyAmount: int):
"""
Buy an amount of a specific stock.
*Paramaters*
------------
user: str
The id of the user buying.
stock: str
The symbol of the stock to buy.
buyAmount: int
The amount of GwendoBucks to use to buy the stock.
*Returns*
---------
send_message: str
The message to return to the user.
"""
if buyAmount < 100:
return "You cannot buy stocks for less than 100 GwendoBucks"
elif self.bot.money.checkBalance(user) < buyAmount:
return "You don't have enough money for that"
elif self.getPrice(stock) <= 0:
return f"{stock} is not traded on the american market."
else:
investments_database = self.bot.database["investments"]
stockPrice = self.getPrice(stock)
userInvestments = investments_database.find_one({"_id": user})
self.bot.money.addMoney(user, -1*buyAmount)
stock = stock.upper()
if userInvestments is not None:
userInvestments = userInvestments["investments"]
if stock in userInvestments:
value = userInvestments[stock]
valueChange = (stockPrice / value["value at purchase"])
currentValue = int(valueChange * value["purchased"])
newAmount = currentValue + buyAmount
value_path = f"investments.{stock}.value at purchase"
updater = {"$set": {value_path: stockPrice}}
investments_database.update_one({"_id": user}, updater)
purchased_path = f"investments.{stock}.purchased"
updater = {"$set": {purchased_path: newAmount}}
investments_database.update_one({"_id": user}, updater)
if value["purchased for"] != "?":
purchasedFor_path = f"investments.{stock}.purchased for"
updater = {"$set": {purchasedFor_path: buyAmount}}
investments_database.update_one({"_id": user}, updater)
else:
updater = {
"$set": {
"investments.{stock}": {
"purchased": buyAmount,
"value at purchase": stockPrice,
"purchased for": buyAmount
}
}
}
investments_database.update_one({"_id": user}, updater)
else:
new_user = {
"_id": user,
"investments": {
stock: {
"purchased": buyAmount,
"value at purchase": stockPrice,
"purchased for": buyAmount
}
}
}
investments_database.insert_one(new_user)
user_name = self.bot.database_funcs.get_name(user)
send_message = "{} bought {} GwendoBucks worth of {} stock"
send_message = send_message.format(user_name, buyAmount, stock)
return send_message
def sellStock(self, user: str, stock: str, sellAmount: int):
"""
Sell an amount of a specific stock.
*Paramaters*
------------
user: str
The id of the user selling.
stock: str
The symbol of the stock to sell.
buyAmount: int
The amount of GwendoBucks to sell for.
*Returns*
---------
send_message: str
The message to return to the user.
"""
if sellAmount <= 0:
return "no"
else:
investments_database = self.bot.database["investments"]
user_data = investments_database.find_one({"_id": user})
userInvestments = user_data["investments"]
stock = stock.upper()
if userInvestments is not None and stock in userInvestments:
value = userInvestments[stock]
stockPrice = self.getPrice(stock)
priceChange = (stockPrice / value["value at purchase"])
purchasedAmount = int(priceChange * value["purchased"])
purchased_path = f"investments.{stock}.purchased"
updater = {"$set": {purchased_path: purchasedAmount}}
investments_database.update_one({"_id": user}, updater)
valueAtPurchase_path = f"investments.{stock}.value at purchase"
updater = {"$set": {valueAtPurchase_path: stockPrice}}
investments_database.update_one({"_id": user}, updater)
if value["purchased"] >= sellAmount:
self.bot.money.addMoney(user, sellAmount)
if sellAmount < value["purchased"]:
purchased_path = f"investments.{stock}.purchased"
updater = {"$inc": {purchased_path: -sellAmount}}
investments_database.update_one({"_id": user}, updater)
purchasedFor_path = f"investments.{stock}.purchased for"
updater = {"$set": {purchasedFor_path: "?"}}
investments_database.update_one({"_id": user}, updater)
else:
updater = {"$unset": {f"investments.{stock}": ""}}
investments_database.update_one({"_id": user}, updater)
user_name = self.bot.database_funcs.get_name(user)
send_message = "{} sold {} GwendoBucks worth of {} stock"
return send_message.format(user_name, sellAmount, stock)
else:
return f"You don't have enough {stock} stocks to do that"
else:
return f"You don't have any {stock} stock"
async def parseInvest(self, ctx: SlashContext, parameters: str):
"""
Parse an invest command. TO BE DELETED.
*Parameters*
------------
ctx: discord_slash.context.SlashContext
The context of the slash command.
parameters: str
The parameters of the command.
"""
await self.bot.defer(ctx)
user = f"#{ctx.author.id}"
if parameters.startswith("check"):
commands = parameters.split(" ")
if len(commands) == 1:
response = self.getPortfolio(user)
else:
price = self.getPrice(commands[1])
if price == 0:
response = "{} is not traded on the american market."
response = response.format(commands[0].upper())
else:
price = f"{price:,}".replace(",", ".")
response = self.bot.long_strings["Stock value"]
response = response.format(commands[1].upper(), price)
elif parameters.startswith("buy"):
commands = parameters.split(" ")
if len(commands) == 3:
response = self.buyStock(user, commands[1], int(commands[2]))
else:
response = self.bot.long_strings["Stock parameters"]
elif parameters.startswith("sell"):
commands = parameters.split(" ")
if len(commands) == 3:
response = self.sellStock(user, commands[1], int(commands[2]))
else:
response = self.bot.long_strings["Stock parameters"]
else:
response = "Incorrect parameters"
if response.startswith("**"):
responses = response.split("\n")
text = "\n".join(responses[1:])
embedParams = {
"title": responses[0],
"description": text,
"colour": 0x00FF00
}
em = discord.Embed(**embedParams)
await ctx.send(embed=em)
else:
await ctx.send(response)

151
gwendolyn/funcs/games/money.py
View File

@ -1,151 +0,0 @@
"""
Contains the code that deals with money.
*Classes*
---------
Money
Deals with money.
"""
import discord_slash # Used for typehints
import discord # Used for typehints
class Money():
"""
Deals with money.
*Methods*
---------
checkBalance(user: str)
sendBalance(ctx: discord_slash.context.SlashContext)
addMoney(user: str, amount: int)
giveMoney(ctx: discord_slash.context.SlashContext, user: discord.User,
amount: int)
*Attributes*
------------
bot: Gwendolyn
The instance of Gwendolyn
database: pymongo.Client
The mongo database
"""
def __init__(self, bot):
"""Initialize the class."""
self.bot = bot
self.database = bot.database
def checkBalance(self, user: str):
"""
Get the account balance of a user.
*Parameters*
------------
user: str
The user to get the balance of.
*Returns*
---------
balance: int
The balance of the user's account.
"""
self.bot.log("checking "+user+"'s account balance")
user_data = self.database["users"].find_one({"_id": user})
if user_data is not None:
return user_data["money"]
else:
return 0
async def sendBalance(self, ctx: discord_slash.context.SlashContext):
"""
Get your own account balance.
*Parameters*
------------
ctx: discord_slash.context.SlashContext
The context of the command.
"""
await self.bot.defer(ctx)
response = self.checkBalance("#"+str(ctx.author.id))
user_name = ctx.author.display_name
if response == 1:
new_message = f"{user_name} has {response} GwendoBuck"
else:
new_message = f"{user_name} has {response} GwendoBucks"
await ctx.send(new_message)
# Adds money to the account of a user
def addMoney(self, user: str, amount: int):
"""
Add money to a user account.
*Parameters*
------------
user: str
The id of the user to give money.
amount: int
The amount to add to the user's account.
"""
self.bot.log("adding "+str(amount)+" to "+user+"'s account")
user_data = self.database["users"].find_one({"_id": user})
if user_data is not None:
updater = {"$inc": {"money": amount}}
self.database["users"].update_one({"_id": user}, updater)
else:
new_user = {
"_id": user,
"user name": self.bot.database_funcs.get_name(user),
"money": amount
}
self.database["users"].insert_one(new_user)
# Transfers money from one user to another
async def giveMoney(self, ctx: discord_slash.context.SlashContext,
user: discord.User, amount: int):
"""
Give someone else money from your account.
*Parameters*
------------
ctx: discord_slash.context.SlashContext
The context of the command.
user: discord.User
The user to give money.
amount: int
The amount to transfer.
"""
await self.bot.defer(ctx)
username = user.display_name
if self.bot.database_funcs.get_id(username) is None:
async for member in ctx.guild.fetch_members(limit=None):
if member.display_name.lower() == username.lower():
username = member.display_name
user_id = f"#{member.id}"
new_user = {
"_id": user_id,
"user name": username,
"money": 0
}
self.bot.database["users"].insert_one(new_user)
userid = f"#{ctx.author.id}"
user_data = self.database["users"].find_one({"_id": userid})
targetUser = self.bot.database_funcs.get_id(username)
if amount <= 0:
self.bot.log("They tried to steal")
await ctx.send("Yeah, no. You can't do that")
elif targetUser is None:
self.bot.log("They weren't in the system")
await ctx.send("The target doesn't exist")
elif user_data is None or user_data["money"] < amount:
self.bot.log("They didn't have enough GwendoBucks")
await ctx.send("You don't have that many GwendoBuck")
else:
self.addMoney(f"#{ctx.author.id}", -1 * amount)
self.addMoney(targetUser, amount)
await ctx.send(f"Transferred {amount} GwendoBucks to {username}")

205
gwendolyn/funcs/games/trivia.py
View File

@ -1,205 +0,0 @@
"""
Contains code for trivia games.
*Classes*
---------
Trivia
Contains all the code for the trivia commands.
"""
import urllib # Used to get data from api
import json # Used to read data from api
import random # Used to shuffle answers
import asyncio # Used to sleep
from discord_slash.context import SlashContext # Used for type hints
class Trivia():
"""
Contains the code for trivia games.
*Methods*
---------
triviaStart(channel: str) -> str, str, str
triviaAnswer(user: str, channel: str, command: str) -> str
triviaCountPoints(channel: str)
triviaParse(ctx: SlashContext, answer: str)
"""
def __init__(self, bot):
"""Initialize the class."""
self.bot = bot
def triviaStart(self, channel: str):
"""
Start a game of trivia.
Downloads a question with answers, shuffles the wrong answers
with the correct answer and returns the questions and answers.
Also saves the question in the database.
*Parameters*
------------
channel: str
The id of the channel to start the game in
*Returns*
---------
send_message: str
The message to return to the user.
"""
triviaQuestions = self.bot.database["trivia questions"]
question = triviaQuestions.find_one({"_id": channel})
self.bot.log(f"Trying to find a trivia question for {channel}")
if question is None:
apiUrl = "https://opentdb.com/api.php?amount=10&type=multiple"
with urllib.request.urlopen(apiUrl) as response:
data = json.loads(response.read())
question = data["results"][0]["question"]
self.bot.log(f"Found the question \"{question}\"")
answers = data["results"][0]["incorrect_answers"]
answers.append(data["results"][0]["correct_answer"])
random.shuffle(answers)
correctAnswer = data["results"][0]["correct_answer"]
correctAnswer = answers.index(correctAnswer) + 97
newQuestion = {
"_id": channel,
"answer": str(chr(correctAnswer)),
"players": {}
}
triviaQuestions.insert_one(newQuestion)
replacements = {
"&#039;": "\'",
"&quot;": "\"",
"&ldquo;": "\"",
"&rdquo;": "\"",
"&eacute;": "é"
}
question = data["results"][0]["question"]
for key, value in replacements.items():
question = question.replace(key, value)
for answer in answers:
for key, value in replacements.items():
answer = answer.replace(key, value)
return question, answers, correctAnswer
else:
log_message = "There was already a trivia question for that channel"
self.bot.log(log_message)
return self.bot.long_strings["Trivia going on"], "", ""
def triviaAnswer(self, user: str, channel: str, command: str):
"""
Answer the current trivia question.
*Parameters*
------------
user: str
The id of the user who answered.
channel: str
The id of the channel the game is in.
command: str
The user's answer.
*Returns*
---------
send_message: str
The message to send if the function failed.
"""
triviaQuestions = self.bot.database["trivia questions"]
question = triviaQuestions.find_one({"_id": channel})
if command not in ["a", "b", "c", "d"]:
self.bot.log("I didn't quite understand that")
return "I didn't quite understand that"
elif question is None:
self.bot.log("There's no question right now")
return "There's no question right now"
elif user in question["players"]:
self.bot.log(f"{user} has already answered this question")
return f"{user} has already answered this question"
else:
self.bot.log(f"{user} answered the question in {channel}")
updater = {"$set": {f"players.{user}": command}}
triviaQuestions.update_one({"_id": channel}, updater)
return None
def triviaCountPoints(self, channel: str):
"""
Add money to every winner's account.
*Parameters*
------------
channel: str
The id of the channel the game is in.
"""
triviaQuestions = self.bot.database["trivia questions"]
question = triviaQuestions.find_one({"_id": channel})
self.bot.log("Counting points for question in "+channel)
if question is not None:
for player, answer in question["players"].items():
if answer == question["answer"]:
self.bot.money.addMoney(player, 1)
else:
self.bot.log("Couldn't find the questio")
return None
async def triviaParse(self, ctx: SlashContext, answer: str):
"""
Parse a trivia command.
*Parameters*
------------
ctx: SlashContext
The context of the command.
answer: str
The answer, if any.
"""
await self.bot.defer(ctx)
channelId = str(ctx.channel_id)
if answer == "":
question, options, correctAnswer = self.triviaStart(channelId)
if options != "":
results = "**"+question+"**\n"
for x, option in enumerate(options):
results += chr(x+97) + ") "+option+"\n"
await ctx.send(results)
await asyncio.sleep(60)
self.triviaCountPoints(channelId)
delete_gameParams = ["trivia questions", channelId]
self.bot.database_funcs.delete_game(*delete_gameParams)
self.bot.log("Time's up for the trivia question", channelId)
send_message = self.bot.long_strings["Trivia time up"]
format_parameters = [chr(correctAnswer), options[correctAnswer-97]]
send_message = send_message.format(*format_parameters)
await ctx.send(send_message)
else:
await ctx.send(question, hidden=True)
elif answer in ["a", "b", "c", "d"]:
userId = f"#{ctx.author.id}"
response = self.triviaAnswer(userId, channelId, answer)
if response is None:
user_name = ctx.author.display_name
await ctx.send(f"{user_name} answered **{answer}**")
else:
await ctx.send(response)
else:
self.bot.log("I didn't understand that", channelId)
await ctx.send("I didn't understand that")

201
gwendolyn/funcs/games/wordle.py
View File

@ -1,201 +0,0 @@
"""Implementation of Wordle"""
import requests
from PIL import Image, ImageDraw
from .game_base import DatabaseGame, BaseDrawer
from gwendolyn.exceptions import GameNotInDatabase
IMAGE_MARGIN = 90
SQUARE_SIZE = 150
SQUARE_PADDING = 25
ROW_PADDING = 30
FONT_SIZE = 130
# COLORS
BACKGROUND_COLOR = "#2c2f33"
TEXT_COLOR = "#eee"
WRITING_BORDER_COLOR = "#999"
INACTIVE_BORDER_COLOR = "#555"
INCORRECT_COLOR = "#444"
CORRECT_COLOR = "#0a8c20"
PRESENT_COLOR = "#0f7aa8"
COLORS = [INCORRECT_COLOR, PRESENT_COLOR, CORRECT_COLOR]
class WordleGame(DatabaseGame):
"""Implementation of wordle game."""
def __init__(self, bot):
super().__init__(bot, "wordle", WordleDrawer)
self._API_url = "https://api.wordnik.com/v4/words.json/randomWords?" # pylint: disable=invalid-name
api_key = self.bot.credentials["wordnik_key"]
self._APIPARAMS = { # pylint: disable=invalid-name
"hasDictionaryDef": True,
"minCorpusCount": 5000,
"maxCorpusCount": -1,
"minDictionaryCount": 1,
"maxDictionaryCount": -1,
"limit": 1,
"api_key": api_key
}
async def start(self, ctx, letters: int):
if self._test_document(str(ctx.channel_id)):
await ctx.send("There is already a wordle game in this channel.")
self.bot.log("There was already a game going on")
return
params = self._APIPARAMS
params["minLength"] = letters
params["maxLength"] = letters
word = "-"
while "-" in word or "." in word:
response = requests.get(self._API_url, params=params)
if response.json() == []:
ctx.send("Could not find a word. Try again")
return
word = list(response.json()[0]["word"].upper())
self.bot.log(f"Found the word \"{''.join(word)}\"")
game = {"word": word, "guesses": [], "results": []}
await ctx.send("Starting a wordle game.")
await self._start_new(ctx.channel, game, delete=False)
def _get_result(self, guess: list[str], word: list[str]):
result = ["_" for _ in guess]
for i, letter in enumerate(guess):
if letter == word[i]:
result[i] = "*"
for i, letter in enumerate(guess):
if letter in word and result[i] != "*":
same_letter = guess[:i].count(letter)
same_letter += len(
[
l for j,l in
enumerate(guess[i:])
if guess[i:][j] == letter and result[i:][j] == "*"
]
)
if same_letter < word.count(letter):
result[i] = "-"
return result
async def guess(self, ctx, guess: str):
if not guess.isalpha():
await ctx.send("You can only use letters in your guess")
return
guess = list(guess.upper())
try:
game = self.access_document(str(ctx.channel_id))
except GameNotInDatabase:
await ctx.send("No game in channel")
return
if len(guess) != len(game['word']):
await ctx.send(
f"Your guess must be {len(game['word'])} letters long")
return
await ctx.send(f"Guessed {''.join(guess)}")
result = self._get_result(guess, game['word'])
updater = {
"$set": {
f"guesses.{len(game['guesses'])}": guess,
f"results.{len(game['guesses'])}": result
}
}
self._update_document(str(ctx.channel_id), updater)
if result == ["*" for _ in game['word']]:
await ctx.send("You guessed the word! Adding 15 GwendoBucks to your account")
self.bot.money.addMoney(f"#{ctx.author_id}", 15)
await self._end_game(ctx.channel)
elif len(game['guesses']) == 5:
await ctx.send(f"You used up all available guesses. The word was '{''.join(game['word'])}'")
await self._end_game(ctx.channel)
else:
print(len(game['guesses']))
await self._delete_old_image(ctx.channel)
await self._send_image(ctx.channel, delete=False)
class WordleDrawer(BaseDrawer):
def __init__(self, bot, game: WordleGame):
super().__init__(bot, game)
self.default_image = None
self.default_color = BACKGROUND_COLOR
self.default_size = (0, 0)
def _get_size(self, game: dict):
width = (
(len(game['word']) * SQUARE_SIZE) +
((len(game['word']) - 1) * SQUARE_PADDING) +
(2 * IMAGE_MARGIN)
)
height = (
(6 * SQUARE_SIZE) +
(5 * ROW_PADDING) +
(2 * IMAGE_MARGIN)
)
size = (width, height)
return size
def _draw_row(self, row, drawer, font, word: str, colors: list[str] = None,
border_color: str = None):
if colors is None:
colors = [BACKGROUND_COLOR for _ in range(len(word))]
for i, letter in enumerate(word):
y_pos = IMAGE_MARGIN + (row * (SQUARE_SIZE + ROW_PADDING))
x_pos = IMAGE_MARGIN + (i * (SQUARE_SIZE + SQUARE_PADDING))
top_left = (x_pos, y_pos)
bottom_right = (x_pos + SQUARE_SIZE, y_pos + SQUARE_SIZE)
drawer.rounded_rectangle(
(top_left,bottom_right),
10,
colors[i],
border_color,
3
)
text_pos = (
x_pos + (SQUARE_SIZE//2),
y_pos + int(SQUARE_SIZE * 0.6)
)
drawer.text(text_pos, letter, TEXT_COLOR, font=font, anchor="mm")
def _determine_colors(self, results):
return [COLORS[["_","-","*"].index(symbol)] for symbol in results]
def _draw_image(self, game: dict, image: Image.Image):
drawer = ImageDraw.Draw(image)
font = self._get_font(FONT_SIZE)
for i, guess in enumerate(game['guesses']):
colors = self._determine_colors(game['results'][i])
self._draw_row(i, drawer, font, guess, colors)
if len(game["guesses"]) < 6:
self._draw_row(
len(game['guesses']),
drawer,
font,
" "*len(game['word']),
border_color=WRITING_BORDER_COLOR
)
for i in range(5 - len(game['guesses'])):
self._draw_row(
len(game['guesses']) + i + 1,
drawer,
font, " "*len(game['word']),
border_color=INACTIVE_BORDER_COLOR
)
return super()._draw_image(game, image)

5
gwendolyn/funcs/lookup/__init__.py
View File

@ -1,5 +0,0 @@
"""Gwendolyn functions for looking things up."""
__all__ = ["LookupFuncs"]
from .lookup_funcs import LookupFuncs

221
gwendolyn/funcs/lookup/lookup_funcs.py
View File

@ -1,221 +0,0 @@
import math
import json
import discord
from gwendolyn.utils import cap
STATS = [
"strength",
"dexterity",
"constitution",
"intelligence",
"wisdom",
"charisma"
]
def mod(statistic):
"""Calculates D&D modifier."""
modifier = math.floor((statistic-10)/2)
if modifier >= 0:
modifier = "+"+str(modifier)
return modifier
class LookupFuncs():
def __init__(self, bot):
self.bot = bot
self.saves = [
"strength_save",
"dexterity_save",
"constitution_save",
"intelligence_save",
"wisdom_save",
"charisma_save"
]
self.abilities = [
"acrobatics",
"animal_handling",
"arcana",
"athletics",
"deception",
"history",
"insight",
"intimidation",
"investigation",
"medicine",
"nature",
"perception",
"performance",
"persuasion",
"religion",
"sleight_of_hand",
"stealth",
"survival"
]
def _format_monster(self, monster):
# Looks at the information about the monster and
# returns that information in separate variables,
# allowing Gwendolyn to know where to separate
# the messages
types = monster["type"]
if monster["subtype"] != "":
types += " ("+monster["subtype"]+")"
stats = []
for stat in STATS:
value = monster[stat]
stats.append(f"**{cap(stat[:3])}:** {value} ({mod(value)})")
stats = "\t".join(stats[:3]) + "\n" + "\t".join(stats[3:])
saving_throws = []
for save in self.saves:
if save in monster:
value = monster[save]
if monster[save] >= 0:
saving_throws.append(f"{cap(save[:3])} +{value}")
else:
saving_throws.append(f"{cap(save[:3])} {value}")
if saving_throws:
saving_throws = f"\n**Saving Throws:** {', '.join(saving_throws)}"
else:
saving_throws = ""
skills = []
for skill in self.abilities:
if skill in monster:
skill_name = cap(skill.replace("_"," "))
if monster[skill] >= 0:
skills.append(f"{skill_name} +{monster[skill]}")
else:
skills.append(f"{skill_name} {monster[skill]}")
if skills:
skills = f"\n**Skills:** {', '.join(skills)}"
else:
skills = ""
vulnerabilities = monster["damage_vulnerabilities"]
if vulnerabilities != "":
vulnerabilities = "\n**Damage Vulnerabilities** "+vulnerabilities
resistances = monster["damage_resistances"]
if resistances != "":
resistances = "\n**Damage Resistances** "+resistances
immunities = monster["damage_immunities"]
if immunities != "":
immunities = "\n**Damage Immunities** "+immunities
c_immunities = monster["condition_immunities"]
if c_immunities != "":
c_immunities = "\n**Condition Immunities** "+c_immunities
special_abilities = ""
if "special_abilities" in monster:
for ability in monster["special_abilities"]:
special_abilities += "\n\n***"+ability["name"]+".*** "+ability["desc"]
act = ""
if "actions" in monster:
for action in monster["actions"]:
act += "\n\n***"+action["name"]+".*** "+action["desc"]
react = ""
if "reactions" in monster:
for reaction in monster["reactions"]:
react += "\n\n***"+reaction["name"]+".*** "+reaction["desc"]
legendaryActions = ""
if "legendary_actions" in monster:
for action in monster["legendary_actions"]:
legendaryActions += "\n\n***"+action["name"]+".*** "+action["desc"]
hit_dice = monster["hit_dice"]
dice_amount = int(monster["hit_dice"].replace("d"," ").split()[0])
con_mod = math.floor((monster['constitution']-10)/2)
if con_mod < 0:
hit_dice += f" - {abs(con_mod) * dice_amount}"
elif con_mod > 0:
hit_dice += (f" + {con_mod * dice_amount}")
new_part = "\n--------------------"
monster_type = f"*{monster['size']} {types}, {monster['alignment']}*"
basic_info = "\n**Armor Class** "+str(monster["armor_class"])+"\n**Hit Points** "+str(monster["hit_points"])+" ("+hit_dice+")\n**Speed **"+monster["speed"]+new_part+"\n"
info = (monster_type+new_part+basic_info+stats+new_part+saving_throws+skills+vulnerabilities+resistances+immunities+c_immunities+"\n**Senses** "+monster["senses"]+"\n**Languages** "+monster["languages"]+"\n**Challenge** "+monster["challenge_rating"])
monster_info = [(info, monster['name']),
(special_abilities, "Special Abilities"),
(act, "Actions"),
(react, "Reactions"),
(legendaryActions, "Legendary Actions")]
self.bot.log("Returning monster information")
return monster_info
# Looks up a monster
async def monster_func(self, ctx, query):
query = cap(query)
self.bot.log("Looking up "+query)
# 1-letter monsters don't exist
if len(query) < 2:
self.bot.log("Monster name too short")
await ctx.send("I don't know that monster...")
return
# Opens "monsters.json"
monster_file_path = "gwendolyn/resources/lookup/monsters.json"
with open(monster_file_path,"r", encoding="utf-8") as file_pointer:
data = json.load(file_pointer)
for monster in data:
if "name" in monster and str(query) == monster["name"]:
self.bot.log("Found it!")
monster_info = self._format_monster(monster)
# Sends the received information. Separates into separate messages if
# there is too much text
await ctx.send(f"Result for \"{query}\"")
for text, title in monster_info:
if text != "":
if len(text) < 2000:
em = discord.Embed(title = title, description = text, colour=0xDEADBF)
await ctx.channel.send(embed = em)
else:
index = text[:2000].rfind(".")+1
em1 = discord.Embed(title = title, description = text[:index], colour=0xDEADBF)
await ctx.channel.send(embed = em1)
em2 = discord.Embed(title = "", description = text[index+1:], colour=0xDEADBF)
await ctx.channel.send(embed = em2)
break
else:
self.bot.log("Monster not in database")
await ctx.send("I don't know that monster...")
# Looks up a spell
async def spell_func(self, ctx, query):
query = cap(query)
self.bot.log("Looking up "+query)
# Opens "spells.json"
data = json.load(open('gwendolyn/resources/lookup/spells.json', encoding = "utf8"))
if query in data:
self.bot.log("Returning spell information")
send_message = (f"***{query}***\n*{data[query]['level']} level {data[query]['school']}\nCasting Time: {data[query]['casting_time']}\nRange:{data[query]['range']}\nComponents:{data[query]['components']}\nDuration:{data[query]['duration']}*\n \n{data[query]['description']}")
else:
self.bot.log("I don't know that spell")
send_message = "I don't think that's a spell"
if len(send_message) > 2000:
await ctx.send(send_message[:2000])
await ctx.send(send_message[2000:])
else:
await ctx.send(send_message)

5
gwendolyn/funcs/other/__init__.py
View File

@ -1,5 +0,0 @@
"""Misc. functions for Gwendolyn."""
__all__ = ["Other"]
from .other import Other

94
gwendolyn/funcs/other/generators.py
View File

@ -1,94 +0,0 @@
import random
class Generators():
def __init__(self, bot):
self.bot = bot
# Returns a list of all letter pairs in the text
def make_pairs(self, corpus):
for i in range(len(corpus)-1):
yield (corpus[i], corpus[i+1])
# Returns a list of all letter triplets in the text
def make_triplets(self, corpus):
for i in range(len(corpus)-2):
yield (corpus[i], corpus[i+1], corpus[i+2])
# Generates a random name
async def name_gen(self, ctx):
# Makes a list of all names from "names.txt"
with open("gwendolyn/resources/names.txt", "r", encoding='utf8') as file_pointer:
names = file_pointer.read()
corpus = list(names)
# Makes a list of pairs
pairs = self.make_pairs(corpus)
triplets = self.make_triplets(corpus)
letter_dict = {}
# Makes a dictionary of all letters that come after all other letters
for letter_1, letter_2 in pairs:
if letter_1 in letter_dict:
letter_dict[letter_1].append(letter_2)
else:
letter_dict[letter_1] = [letter_2]
for letter_1, letter_2, letter_3 in triplets:
if letter_1+letter_2 in letter_dict:
letter_dict[letter_1+letter_2].append(letter_3)
else:
letter_dict[letter_1+letter_2] = [letter_3]
# Choses a random first letter
first_letter = random.choice(corpus)
# Makes sure the first letter is not something a name can't start with.
while first_letter.islower() or first_letter == " " or first_letter == "-" or first_letter == "\n":
first_letter = random.choice(corpus)
# Starts the name
chain = [first_letter]
# Picks second letter
second_letter = random.choice(letter_dict[chain[-1]])
while second_letter == "\n":
second_letter = random.choice(letter_dict[chain[-1]])
chain.append(second_letter)
done = False
# Creates the name one letter at a time
while not done:
if random.randint(1,10) > 1:
try:
new_letter = random.choice(letter_dict[chain[-2]+chain[-1]])
except KeyError():
new_letter = random.choice(letter_dict[chain[-1]])
else:
new_letter = random.choice(letter_dict[chain[-1]])
chain.append(new_letter)
# Ends name if the name ends
if new_letter == "\n":
done = True
gen_name = "".join(chain)
self.bot.log("Generated "+gen_name[:-1])
# Returns the name
await ctx.send(gen_name)
# Generates a random tavern name
async def tavern_gen(self, ctx):
# _lists first parts, second parts and third parts of tavern names
first_part = ["The Silver","The Golden","The Staggering","The Laughing","The Prancing","The Gilded","The Running","The Howling","The Slaughtered","The Leering","The Drunken","The Leaping","The Roaring","The Frowning","The Lonely","The Wandering","The Mysterious","The Barking","The Black","The Gleaming","The Tap-Dancing","The Sad","The Sexy","The Artificial","The Groovy","The Merciful","The Confused","The Pouting","The Horny","The Okay","The Friendly","The Hungry","The Handicapped","The Fire-breathing","The One-Eyed","The Psychotic","The Mad","The Evil","The Idiotic","The Trusty","The Busty"]
second_part = ["Eel","Dolphin","Dwarf","Pegasus","Pony","Rose","Stag","Wolf","Lamb","Demon","Goat","Spirit","Horde","Jester","Mountain","Eagle","Satyr","Dog","Spider","Star","Dad","Rat","Jeremy","Mouse","Unicorn","Pearl","Ant","Crab","Penguin","Octopus","Lawyer","Ghost","Toad","Handjob","Immigrant","SJW","Dragon","Bard","Sphinx","Soldier","Salmon","Owlbear","Kite","Frost Giant","Arsonist"]
third_part = [" Tavern"," Inn","","","","","","","","",""]
# Picks one of each
gen_tav = random.choice(first_part)+" "+random.choice(second_part)+random.choice(third_part)
self.bot.log("Generated "+gen_tav)
# Return the name
await ctx.send(gen_tav)

85
gwendolyn/funcs/other/nerd_shit.py
View File

@ -1,85 +0,0 @@
import os
import requests
import discord
import wolframalpha
from PIL import Image, ImageDraw, ImageFont
class NerdShit():
def __init__(self, bot):
"""Runs misc commands."""
self.bot = bot
async def wolf_search(self,ctx,content):
await self.bot.defer(ctx)
font = ImageFont.truetype('gwendolyn/resources/fonts/times-new-roman.ttf', 20)
self.bot.log("Requesting data")
bot = wolframalpha.Client(self.bot.credentials["wolfram_alpha_key"])
res = bot.query(content)
self.bot.log("Processing data")
titles = []
pods = []
if int(res.numpods) > 0:
for pod in res.pods:
titles += [pod.title]
for i, sub in enumerate(pod.subpods):
pods += [sub]
if i > 0:
titles += [""]
pod_chunks = [pods[x:x+2] for x in range(0, len(pods), 2)]
title_chunks = [titles[x:x+2] for x in range(0, len(titles), 2)]
await ctx.send(f"Response for \"{content}\"")
for i, chunk in enumerate(pod_chunks):
width = 0
for title in title_chunks[i]:
width = max(width,font.getsize(title)[0])
height = 5
heights = []
for count, pod in enumerate(chunk):
heights += [height]
width = max(width,int(pod.img['@width']))
if title_chunks[i][count] == "":
place_for_text = 0
else:
place_for_text = 30
height += int(pod.img["@height"]) + 10 + place_for_text
width += 10
height += 5
wolf_image = Image.new("RGB",(width,height),color=(255,255,255))
for count, pod in enumerate(chunk):
response = requests.get(pod.img["@src"])
file = open("gwendolyn/resources/wolfTemp.png", "wb")
file.write(response.content)
file.close()
old_image = Image.open("gwendolyn/resources/wolfTemp.png")
old_size = old_image.size
if title_chunks[i][count] == "":
place_for_text = 0
else:
place_for_text = 30
new_size = (width,int(old_size[1]+10+place_for_text))
new_image = Image.new("RGB",new_size,color=(255,255,255))
new_image.paste(old_image, (int((int(old_size[0]+10)-old_size[0])/2),int(((new_size[1]-place_for_text)-old_size[1])/2)+place_for_text))
if title_chunks[i][count] != "":
drawer = ImageDraw.Draw(new_image,"RGB")
drawer.text((5,7),title_chunks[i][count],font=font,fill=(150,150,150))
wolf_image.paste(new_image,(0,heights[count]))
new_image.close()
old_image.close()
count += 1
wolf_image.save("gwendolyn/resources/wolf.png")
wolf_image.close()
await ctx.channel.send(file = discord.File("gwendolyn/resources/wolf.png"))
os.remove("gwendolyn/resources/wolf.png")
os.remove("gwendolyn/resources/wolfTemp.png")
else:
self.bot.log("No returned data")
await ctx.send("Could not find anything relating to your search")

192
gwendolyn/funcs/other/other.py
View File

@ -1,192 +0,0 @@
import random # Used in movie_func
import datetime # Used in hello_func
import urllib # Used in image_func
import ast
import imdb # Used in movie_func
import discord # Used in movie_func
import lxml # Used in image_func
import fandom # Used in find_wiki_page
import d20 # Used in roll_dice
from .plex import Plex
from .nerd_shit import NerdShit
from .generators import Generators
fandom.set_lang("da")
fandom.set_wiki("senkulpa")
class MyStringifier(d20.MarkdownStringifier):
def _str_expression(self, node):
if node.comment is None:
result_text = "Result"
else:
result_text = node.comment.capitalize()
return f"**{result_text}**: {self._stringify(node.roll)}\n**Total**: {int(node.total)}"
class Other():
def __init__(self, bot):
self.bot = bot
self.plex = Plex(self.bot)
self.nerd_shit = NerdShit(self.bot)
self.generators = Generators(self.bot)
# Picks a random movie and returns information about it
async def movie_func(self, ctx):
await self.bot.defer(ctx)
self.bot.log("Creating IMDb object")
imdb_client = imdb.IMDb()
self.bot.log("Picking a movie")
with open("gwendolyn/resources/movies.txt", "r") as file_pointer:
movie_list = file_pointer.read().split("\n")
movie_name = random.choice(movie_list)
self.bot.log(f"Searching for {movie_name}")
search_result = imdb_client.search_movie(movie_name)
self.bot.log("Getting the data")
movie = search_result[0]
imdb_client.update(movie)
self.bot.log("Successfully ran /movie")
title = movie["title"]
plot = movie['plot'][0].split("::")[0]
cover = movie['cover url'].replace("150","600").replace("101","404")
cast = ", ".join([i["name"] for i in movie['cast'][:5]])
embed = discord.Embed(title=title, description=plot, color=0x24ec19)
embed.set_thumbnail(url=cover)
embed.add_field(name="Cast", value=cast,inline = True)
await ctx.send(embed = embed)
# Responds with a greeting of a time-appropriate maner
async def hello_func(self, ctx):
def time_in_range(start, end, i):
# Return true if i is in the range [start, end]
if start <= end:
return start <= i <= end
else:
return start <= i or i <= end
author = ctx.author.display_name
now = datetime.datetime.now()
if time_in_range(now.replace(hour=5, minute=0, second=0, microsecond=0),now.replace(hour=10, minute=0, second=0, microsecond=0), now):
send_message = "Good morning, "+str(author)
elif time_in_range(now.replace(hour=13, minute=0, second=0, microsecond=0),now.replace(hour=18, minute=0, second=0, microsecond=0), now):
send_message = "Good afternoon, "+str(author)
elif time_in_range(now.replace(hour=18, minute=0, second=0, microsecond=0),now.replace(hour=22, minute=0, second=0, microsecond=0), now):
send_message = "Good evening, "+str(author)
elif time_in_range(now.replace(hour=22, minute=0, second=0, microsecond=0),now.replace(hour=23, minute=59, second=59, microsecond=0), now):
send_message = "Good night, "+str(author)
else:
send_message = "Hello, "+str(author)
await ctx.send(send_message)
# Finds a random picture online
async def image_func(self, ctx):
# Picks a type of camera, which decides the naming scheme
cams = ("one","two","three","four")
cam = random.choice(cams)
self.bot.log("Chose cam type "+cam)
if cam == "one":
search = "img_" + ''.join(
[str(random.randint(0,9)) for _ in range(4)]
)
elif cam == "two":
year = str(random.randint(2012,2016))
month = str(random.randint(1,12)).zfill(2)
day = str(random.randint(1,29)).zfill(2)
search = f"IMG_{year}{month}{day}"
elif cam == "three":
search = f"IMAG_{str(random.randint(1,500)).zfill(4)}"
elif cam == "four":
search = "DSC_" + ''.join(
[str(random.randint(0,9)) for _ in range(4)]
)
self.bot.log("Searching for "+search)
# Searches for the image and reads the resulting web page
page = urllib.request.urlopen("https://www.bing.com/images/search?q="+search+"&safesearch=off")
read = page.read()
tree = lxml.etree.HTML(read)
images = tree.xpath('//a[@class = "iusc"]/@m')
if len(images) == 0:
await ctx.send("Found no images")
else:
# Picks an image
number = random.randint(1,len(images))-1
image = ast.literal_eval(str(images[number]))
image_url = image["murl"]
self.bot.log("Picked image number "+str(number))
# Returns the image
self.bot.log("Successfully returned an image")
await ctx.send(image_url)
# Finds a page from the Senkulpa Wikia
async def find_wiki_page(self, ctx, search : str):
await self.bot.defer(ctx)
found_page = False
if search != "":
self.bot.log("Trying to find wiki page for "+search)
search_results = fandom.search(search)
if len(search_results) > 0:
found_page = True
search_result = search_results[0]
else:
self.bot.log("Couldn't find the page")
await ctx.send("Couldn't find page")
else:
found_page = True
self.bot.log("Searching for a random page")
search_result = fandom.random()
if found_page:
self.bot.log(f"Found page \"{search_result[0]}\"")
page = fandom.page(pageid = search_result[1])
content = page.summary
images = page.images
if len(images) > 0:
image = images[0]
else:
image = ""
self.bot.log("Sending the embedded message",str(ctx.channel_id))
content += f"\n[Læs mere]({page.url})"
embed = discord.Embed(title = page.title, description = content, colour=0xDEADBF)
if image != "":
embed.set_thumbnail(url=image)
await ctx.send(embed = embed)
async def roll_dice(self, ctx, roll_string):
user = ctx.author.display_name
while len(roll_string) > 1 and roll_string[0] == " ":
roll_string = roll_string[1:]
roll = d20.roll(roll_string, allow_comments=True, stringifier=MyStringifier())
await ctx.send(f"{user} :game_die:\n{roll}")
async def help_func(self, ctx, command):
if command == "":
with open("gwendolyn/resources/help/help.txt",encoding="utf-8") as file_pointer:
text = file_pointer.read()
embed = discord.Embed(title = "Help", description = text,colour = 0x59f442)
await ctx.send(embed = embed)
else:
self.bot.log(f"Looking for help-{command}.txt",str(ctx.channel_id))
with open(f"gwendolyn/resources/help/help-{command}.txt",encoding="utf-8") as file_pointer:
text = file_pointer.read()
embed = discord.Embed(title = command.capitalize(), description = text,colour = 0x59f442)
await ctx.send(embed = embed)

600
gwendolyn/funcs/other/plex.py
View File

@ -1,600 +0,0 @@
"""Plex integration with the bot."""
from math import floor, ceil
import time
import asyncio
import requests
import imdb
import discord
import xmltodict
from discord_slash.utils.manage_components import (create_button,
create_actionrow)
from discord_slash.model import ButtonStyle
from gwendolyn.utils import encode_id
class Plex():
"""Container for Plex functions and commands."""
def __init__(self,bot):
self.bot = bot
self.credentials = self.bot.credentials
self.long_strings = self.bot.long_strings
server_ip = ["localhost", "192.168.0.40"][self.bot.options["testing"]]
self.radarr_url = "http://"+server_ip+":7878/api/v3/"
self.sonarr_url = "http://"+server_ip+":8989/api/"
self.qbittorrent_url = "http://"+server_ip+":8080/api/v2/"
self.movie_path = "/media/plex/Server/movies/"
self.show_path = "/media/plex/Server/Shows/"
async def request_movie(self, ctx, movie_name):
"""Request a movie for the Plex Server"""
await self.bot.defer(ctx)
self.bot.log("Searching for "+movie_name)
movie_list = imdb.IMDb().search_movie(movie_name)
movies = []
for movie in movie_list:
if movie["kind"] == "movie":
movies.append(movie)
if len(movies) > 5:
movies = movies[:5]
if len(movies) == 1:
message_title = "**Is it this movie?**"
else:
message_title = "**Is it any of these movies?**"
message_text = ""
imdb_ids = []
for i, movie in enumerate(movies):
try:
message_text += "\n"+str(i+1)+") "+movie["title"]
try:
message_text += " ("+str(movie["year"])+")"
except KeyError:
self.bot.log(f"{movie['title']} has no year.")
except KeyError:
message_text += "Error"
imdb_ids.append(movie.movieID)
self.bot.log(
f"Returning a list of {len(movies)} possible movies: {imdb_ids}"
)
embed = discord.Embed(
title=message_title,
description=message_text,
colour=0x00FF00
)
buttons = []
if len(movies) == 1:
buttons.append(create_button(
style=ButtonStyle.green,
label="✓",
custom_id=encode_id(["plex", "movie", str(imdb_ids[0])])
)
)
else:
for i in range(len(movies)):
buttons.append(
create_button(
style=ButtonStyle.blue,
label=str(i+1),
custom_id=encode_id(["plex", "movie", str(imdb_ids[i])])
)
)
buttons.append(create_button(
style=ButtonStyle.red,
label="X",
custom_id=encode_id(["plex", "movie", "x"])
)
)
action_rows = []
for i in range(((len(buttons)-1)//5)+1):
action_rows.append(
create_actionrow(
*buttons[(i*5):(min(len(buttons),i*5+5))]
)
)
await ctx.send(embed=embed, components=action_rows)
async def add_movie(self, message, imdb_id, edit_message = True):
"""Add a movie to Plex server."""
if not edit_message:
await message.delete()
if imdb_id == "X":
self.bot.log("Did not find what the user was searching for")
message_text = "Try searching for the IMDB id"
else:
self.bot.log("Trying to add movie "+str(imdb_id))
# Searches for the movie using the imdb id through Radarr
api_key = self.credentials["radarr_key"]
request_url = self.radarr_url+"movie/lookup/imdb?imdbId=tt"+imdb_id
request_url += "&apiKey="+api_key
response = requests.get(request_url)
# Makes the dict used for the post request
lookup_data = response.json()
post_data = {
"qualityProfileId": 1,
"rootFolderPath" : self.movie_path,
"monitored" : True,
"addOptions": {"searchForMovie": True}
}
for key in ["tmdbId","title","titleSlug","images","year"]:
post_data.update({key : lookup_data[key]})
# Makes the post request
response = requests.post(
url = self.radarr_url+"movie?apikey="+api_key,
json = post_data
)
# Deciphers the response
if response.status_code == 201:
self.bot.log("Added "+post_data["title"]+" to Plex")
message_text = "{} successfully added to Plex".format(
post_data["title"]
)
elif response.status_code == 400:
self.bot.log("The movie was already on plex")
message_text = self.long_strings["Already on Plex"].format(
post_data['title']
)
else:
self.bot.log(str(response.status_code)+" "+response.reason)
message_text = "Something went wrong",
if edit_message:
await message.edit(
embed = None,
content = message_text,
components = []
)
else:
await message.channel.send(message_text)
async def request_show(self, ctx, show_name):
"""Request a show for the Plex server."""
await self.bot.defer(ctx)
self.bot.log("Searching for "+show_name)
movies = imdb.IMDb().search_movie(show_name) # Replace with tvdb
shows = []
for movie in movies:
if movie["kind"] in ["tv series","tv miniseries"]:
shows.append(movie)
if len(shows) > 5:
shows = shows[:5]
if len(shows) == 1:
message_title = "**Is it this show?**"
else:
message_title = "**Is it any of these shows?**"
message_text = ""
imdb_ids = []
for i, show in enumerate(shows):
try:
message_text += f"\n{i+1}) {show['title']} ({show['year']})"
except KeyError:
try:
message_text += "\n"+str(i+1)+") "+show["title"]
except KeyError:
message_text += "Error"
imdb_ids.append(show.movieID)
self.bot.log(
f"Returning a list of {len(shows)} possible shows: {imdb_ids}"
)
embed = discord.Embed(
title=message_title,
description=message_text,
colour=0x00FF00
)
buttons = []
if len(shows) == 1:
buttons.append(create_button(
style=ButtonStyle.green,
label="✓",
custom_id=encode_id(["plex", "show", str(imdb_ids[0])])
)
)
else:
for i in range(len(shows)):
buttons.append(
create_button(
style=ButtonStyle.blue,
label=str(i+1),
custom_id=encode_id(["plex", "show", str(imdb_ids[i])])
)
)
buttons.append(create_button(
style=ButtonStyle.red,
label="X",
custom_id=encode_id(["plex", "show", "x"])
)
)
action_rows = []
for i in range(((len(buttons)-1)//5)+1):
action_rows.append(
create_actionrow(
*buttons[(i*5):(min(len(buttons),i*5+5))]
)
)
await ctx.send(embed=embed, components=action_rows)
async def add_show(self, message, imdb_id, edit_message = True):
"""Add the requested show to Plex."""
if imdb_id == "X":
self.bot.log("Did not find what the user was searching for")
message_text = "Try searching for the IMDB id"
else:
self.bot.log("Trying to add show "+str(imdb_id))
# Finds the tvdb id
tvdb_api_url = "https://thetvdb.com/api/"
tvdb_method = "GetSeriesByRemoteID.php"
tvdb_request_url = f"{tvdb_api_url}{tvdb_method}"
tvdb_id = xmltodict.parse(
requests.get(
tvdb_request_url+f"?imdbid=tt{imdb_id}",
headers = {"ContentType" : "application/json"}
).text
)['Data']['Series']['seriesid']
# Finds the rest of the information using Sonarr
api_key = self.credentials["sonarr_key"]
request_url = self.sonarr_url+"series/lookup?term="
request_url += f"tvdb:{tvdb_id}"
request_url += "&apiKey="+api_key
response = requests.get(request_url)
# Makes the dict used for the post request
lookup_data = response.json()[0]
post_data = {
"ProfileId" : 1,
"rootFolder_path" : self.show_path,
"monitored" : True,
"addOptions" : {"searchForMissingEpisodes" : True}
}
for key in ["tvdbId","title","titleSlug","images","seasons"]:
post_data.update({key : lookup_data[key]})
# Makes the post request
response = requests.post(
url= self.sonarr_url+"series?apikey="+api_key,
json = post_data
)
# Deciphers the response
if response.status_code == 201:
self.bot.log("Added a "+post_data["title"]+" to Plex")
message_text = post_data["title"]+" successfully added to Plex"
elif response.status_code == 400:
message_text = self.long_strings["Already on Plex"].format(
post_data['title']
)
else:
self.bot.log(str(response.status_code)+" "+response.reason)
message_text = "Something went wrong"
if edit_message:
await message.edit(
embed = None,
content = message_text,
components = []
)
else:
await message.channel.send(message_text)
async def __generate_download_list(self, show_dm, show_movies, show_shows,
episodes):
"""Generate a list of all torrents.
*Returns*
message_text: str
A formatted list of all torrents
all_downloaded: bool
Whether all torrents are downloaded
"""
self.bot.log("Generating torrent list")
title_width = 100
message = []
all_downloaded = True
if show_dm:
message.append("")
dm_section_title = "*Torrent Downloads*"
dm_section_title_line = "-"*((title_width-len(dm_section_title))//2)
message.append(
dm_section_title_line+dm_section_title+dm_section_title_line
)
login_url = self.qbittorrent_url+"auth/login"
username = self.credentials["qbittorrent_username"]
password = self.credentials["qbittorrent_password"]
login_url += f"?username={username}&password={password}"
cookie = {"SID": requests.get(login_url).cookies.values()[0]}
response = requests.get(
self.qbittorrent_url+"torrents/info",
cookies=cookie
)
torrent_list = response.json()
if len(torrent_list) > 0:
for torrent in torrent_list:
if torrent['category'] not in ["radarr", "tv-sonarr"]:
break
torrent_name = torrent["name"]
if len(torrent_name) > 30:
if torrent_name[26] == " ":
torrent_name = torrent_name[:26]+"...."
else:
torrent_name = torrent_name[:27]+"..."
while len(torrent_name) < 30:
torrent_name += " "
if torrent["size"] == 0:
download_ratio = 0
elif torrent["amount_left"] == 0:
download_ratio = 1
else:
download_ratio = min(
torrent["downloaded"]/torrent["size"],
1
)
progress_bar = "|"+("█"*floor(download_ratio*20))
while len(progress_bar) < 21:
progress_bar += " "
progress_bar += "| "+str(floor(download_ratio*100))+"%"
while len(progress_bar) < 27:
progress_bar += " "
eta_in_seconds = torrent["eta"]
if eta_in_seconds >= 8640000:
eta = "∞"
else:
eta = ""
if eta_in_seconds >= 86400:
eta += str(floor(eta_in_seconds/86400))+"d "
if eta_in_seconds >= 3600:
eta += str(floor((eta_in_seconds%86400)/3600))+"h "
if eta_in_seconds >= 60:
eta += str(floor((eta_in_seconds%3600)/60))+"m "
eta += str(eta_in_seconds%60)+"s"
torrent_info = f"{torrent_name} {progress_bar} "
torrent_info += f"(Eta: {eta})"
if torrent["state"] == "stalledDL":
torrent_info += " (Stalled)"
if not (download_ratio == 1 and
torrent["last_activity"] < time.time()-7200):
message.append(torrent_info)
if download_ratio < 1 and torrent["state"] != "stalledDL":
all_downloaded = False
else:
message.append("No torrents currently downloading")
if show_movies:
message.append("")
movies_section_title = "*Missing movies not downloading*"
movies_section_line = (
"-"*((title_width-len(movies_section_title))//2)
)
message.append(
movies_section_line+movies_section_title+movies_section_line
)
movie_list = requests.get(
self.radarr_url+"movie?apiKey="+self.credentials["radarr_key"]
).json()
print(
self.radarr_url+"movie?apiKey="+self.credentials["radarr_key"]
)
movie_queue = requests.get(
self.radarr_url+"queue?apiKey="+self.credentials["radarr_key"]
).json()
movie_queue_ids = []
for queue_item in movie_queue["records"]:
movie_queue_ids.append(queue_item["movieId"])
for movie in movie_list:
if (not movie["hasFile"] and
movie["id"] not in movie_queue_ids):
movie_name = movie["title"]
if len(movie_name) > 40:
if movie_name[36] == " ":
movie_name = movie_name[:36]+"...."
else:
movie_name = movie_name[:37]+"..."
while len(movie_name) < 41:
movie_name += " "
if movie["monitored"]:
movie_info = movie_name+"Could not find a torrent"
else:
movie_info = self.long_strings["No torrent"].format(
movie_name
)
message.append(movie_info)
if show_shows:
message.append("")
show_section_title = "*Missing shows not downloading*"
show_section_line = "-"*((title_width-len(show_section_title))//2)
message.append(
show_section_line+show_section_title+show_section_line
)
show_list = requests.get(
self.sonarr_url+"series?apiKey="+self.credentials["sonarr_key"]
).json()
for show in show_list:
if show["seasons"][0]["seasonNumber"] == 0:
seasons = show["seasons"][1:]
else:
seasons = show["seasons"]
if any(
(
i["statistics"]["episodeCount"] !=
i["statistics"]["totalEpisodeCount"]
) for i in seasons):
if all(
i["statistics"]["episodeCount"] == 0 for i in seasons
):
message.append(show["title"] + " (all episodes)")
else:
if episodes:
missing_episodes = sum(
(i["statistics"]["totalEpisodeCount"] -
i["statistics"]["episodeCount"])
for i in seasons)
message.append(
f"{show['title']} ({missing_episodes} episodes)"
)
message.append("-"*title_width)
message_text = "```"+"\n".join(message[1:])+"```"
if message_text == "``````":
message_text = self.long_strings["No torrents downloading"]
return message_text, all_downloaded
async def downloading(self, ctx, content):
"""Send message with list of all downloading torrents."""
async def send_long_message(ctx,message_text):
if len(message_text) <= 1994:
await ctx.send("```"+message_text+"```")
else:
cut_off_index = message_text[:1994].rfind("\n")
await ctx.send("```"+message_text[:cut_off_index]+"```")
await send_long_message(ctx,message_text[cut_off_index+1:])
await self.bot.defer(ctx)
# showDM, showMovies, showShows, episodes
parameters = [False, False, False, False]
show_dm_args = ["d", "dm", "downloading", "downloadmanager"]
show_movies_args = ["m", "movies"]
show_shows_args = ["s", "shows", "series"]
show_episode_args = ["e", "episodes"]
arg_list = [
show_dm_args, show_movies_args, show_shows_args, show_episode_args
]
input_args = []
valid_arguments = True
while content != "" and valid_arguments:
if content[0] == " ":
content = content[1:]
elif content[0] == "-":
if content[1] == "-":
arg_start = 2
if " " in content:
arg_stop = content.find(" ")
else:
arg_stop = None
else:
arg_start = 1
arg_stop = 2
input_args.append(content[arg_start:arg_stop])
if arg_stop is None:
content = ""
else:
content = content[arg_stop:]
else:
valid_arguments = False
if valid_arguments:
for arg_index, arg_aliases in enumerate(arg_list):
arg_in_input = [i in input_args for i in arg_aliases]
if any(arg_in_input):
input_args.remove(arg_aliases[arg_in_input.index(True)])
parameters[arg_index] = True
if len(input_args) != 0 or (not parameters[2] and parameters[3]):
valid_arguments = False
show_anything = any(i for i in parameters)
if not (valid_arguments and show_anything):
await ctx.send(self.long_strings["Invalid parameters"])
else:
message_text, all_downloaded = await self.__generate_download_list(
*parameters
)
if not message_text.startswith("```"):
await ctx.send(message_text)
elif len(message_text) > 2000:
message_text = message_text[3:-3]
await send_long_message(ctx,message_text)
elif all_downloaded:
await ctx.send(message_text)
else:
updates_left = 60
message_text = self.long_strings["Update"].format(
message_text[:-3], ceil(updates_left/6)
)
old_message = await ctx.send(message_text)
while ((not all_downloaded) and updates_left > 0):
await asyncio.sleep(10)
updates_left -= 1
message_text, all_downloaded = await (
self.__generate_download_list(*parameters)
)
message_text = self.long_strings["Update"].format(
message_text[:-3],
ceil(updates_left/6)
)
await old_message.edit(content = message_text)
message_text, all_downloaded = await (
self.__generate_download_list(*parameters)
)
if message_text.startswith("```"):
if all_downloaded:
self.bot.log("All torrents are downloaded")
else:
message_text = self.long_strings["No updates"].format(
message_text[:-3]
)
self.bot.log("The message updated 20 times")
await old_message.edit(content = message_text)

5
gwendolyn/funcs/star_wars_funcs/__init__.py
View File

@ -1,5 +0,0 @@
"""Functions related to the Star Wars TTRPG."""
__all__ = ["StarWars"]
from .star_wars import StarWars

10
gwendolyn/funcs/star_wars_funcs/star_wars.py
View File

@ -1,10 +0,0 @@
from .star_wars_char import StarWarsChar
from .star_wars_roll import StarWarsRoll
from .star_wars_destiny import StarWarsDestiny
class StarWars():
def __init__(self, bot):
self.bot = bot
self.character = StarWarsChar(self.bot)
self.roll = StarWarsRoll(self.bot)
self.destiny = StarWarsDestiny(self.bot)

528
gwendolyn/funcs/star_wars_funcs/star_wars_char.py
View File

@ -1,528 +0,0 @@
import json
import string
import discord
class StarWarsChar():
def __init__(self, bot):
self.bot = bot
def get_char_name(self, user : str):
self.bot.log("Getting name for "+self.bot.database_funcs.get_name(user)+"'s character")
user_character = self.bot.database["starwars characters"].find_one({"_id":user})
if user_character != None:
self.bot.log("Name is "+user_character["Name"])
return user_character["Name"]
else:
self.bot.log("Just using "+self.bot.database_funcs.get_name(user))
return self.bot.database_funcs.get_name(user)
def set_up_dict(self, cmd : dict):
self.bot.log("Setting up a dictionary in a nice way")
if bool(cmd):
keys = list(cmd)
values = list(cmd.values())
result = ""
if isinstance(values[0],dict):
return ", ".join(values)
else:
for i, key in enumerate(keys):
if type(key) is list:
if i%3 != 2:
result += "**" + key + "**" + ": " + ", ".join(values[i]) + " "
else:
result += "**" + key + "**" + ": " + ", ".join(values[i]) + "\n"
else:
if i%3 != 2:
result += "**" + key + "**" + ": " + str(values[i]) + " "
else:
result += "**" + key + "**" + ": " + str(values[i]) + "\n"
self.bot.log("Returning a dictionary, but well formatted")
return result
else:
self.bot.log("Couldn't find anything")
return "There doesn't seem to be anything here..."
def look_up(self, data : dict, key : str, cmd : str = ""):
if cmd == " ":
cmd = ""
elif cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
self.bot.log("Looking up "+key)
if key in data:
self.bot.log(key+" exists")
if cmd == "":
if type(data[key]) is dict and key != "Weapons":
return self.set_up_dict(data[key])
elif key == "Weapons":
self.bot.log("Does this even get used? I'm too scared to delete it")
if bool(data[key]):
self.bot.log("Found "+(", ".join(list(data[key]))))
return ", ".join(list(data[key]))
else:
self.bot.log("There is nothing here")
return "There doesn't seem to be anything here..."
else:
if str(data[key]) != "":
self.bot.log("Returning "+str(data[key]))
return data[key]
else:
self.bot.log("There was nothing there")
return "There doesn't seem to be anything here"
elif cmd[0] == '+':
self.bot.log("Trying to add to "+key)
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("Yeah, that fucked up")
return "Can't do that"
if type(data[key]) is int:
try:
new_value = data[key] + int(cmd)
data[key] = new_value
self.bot.log("Added "+cmd+" to "+key)
return data
except:
self.bot.log("Couldn't add "+cmd+" to "+key)
return "Can't add that"
elif type(data[key]) is list:
try:
data[key].append(cmd)
self.bot.log("Added "+cmd+" to "+key)
return data
except:
self.bot.log("Couldn't add "+cmd+" to "+key)
return "Can't add that"
else:
self.bot.log("Yeah, I can't add that to "+key)
return "Can't add that"
elif cmd[0] == '-':
self.bot.log("Trying to remove/subtract from "+key)
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("Yeah, that fucked up")
return "Can't do that"
if type(data[key]) is int:
try:
new_value = data[key] - int(cmd)
data[key] = new_value
self.bot.log("Subtracted "+cmd+" from "+key)
return data
except:
self.bot.log("Couldn't subtract "+cmd+" from "+key)
return "Can't remove that"
elif type(data[key]) is list:
try:
data[key].remove(cmd)
self.bot.log("Removed "+cmd+" from "+key)
return data
except:
self.bot.log("Couldn't remove "+cmd+" from "+key)
return "Can't remove that"
else:
self.bot.log("Yeah, I can't remove/subtract that from "+key)
return "Can't remove that"
else:
while cmd[0] == ' ':
cmd = cmd[1:]
if type(data[key]) is dict:
new_key = cmd.split(" ")[0]
cmd = cmd[len(new_key):]
if cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
self.bot.log("Looking up "+new_key+" in "+key)
look_up_result = self.look_up(data[key],new_key,cmd)
if type(look_up_result) is dict:
data[key] = look_up_result
return data
else:
return look_up_result
elif type(data[key]) != list:
self.bot.log("Trying to change "+key+" to "+cmd)
try:
cmd = type(data[key])(cmd)
data[key] = cmd
self.bot.log("Did that")
return data
except:
self.bot.log("No. That did not work")
return "Wrong data type"
else:
self.bot.log("Yeah, that didn't work")
return "Wrong data type"
else:
self.bot.log("Couldn't find "+key)
self.bot.log("Testing to see if it's a multi-word key")
cmd = key + " " + cmd
words = cmd.split(" ")
search = ""
i = 0
while search not in data:
try:
search += " " + words[i]
i += 1
except:
self.bot.log("It wasn't. "+search+" doesn't exist")
return search + " doesn't exist"
if search[0] == " ":
search = search[1:]
self.bot.log("Yeah! Did that! The key was "+search)
cmd = cmd[len(search):]
if cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
if cmd == "":
self.bot.log("Returning "+search)
return self.set_up_dict(data[search])
else:
new_key = cmd.split(" ")[0]
cmd = cmd[len(new_key):]
if cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
look_up_result = self.look_up(data[search],new_key,cmd)
if type(look_up_result) is dict:
data[search] = look_up_result
return data
else:
return look_up_result
def character_sheet(self,character : dict):
self.bot.log("Setting up a character sheet for "+character["Name"])
divider = "--------------------\n"
name = character["Name"]
textf = ""
if character["Force-rating"] != 0:
textf = "\n**Force Rating**: "+str(character["Force-rating"])
text1 = "**Species**: "+character["Species"]+"\n**Career**: "+character["Career"]+"\n**Specialization Trees**: "+", ".join(character["Specialization-trees"])+textf+"\n**Soak**: "+str(character["Soak"])
text2 = "\n\n**Wounds**: "+str(character["Wounds"])+"/"+str(character["Wound-threshold"])+"\n**Strain**: "+str(character["Strain"])+"/"+str(character["Strain-threshold"])
text3 = self.set_up_dict(character["Characteristics"])
text4 = self.set_up_dict(character["Skills"])
text5 = ""
text6 = ""
text7 = ""
text8 = ""
if bool(character["Talents"]):
text5 = "**Talents**: "+", ".join(list(character["Talents"]))+"\n\n"
if bool(character["Force-powers"]):
text6 = "**Force Powers**: "+", ".join(list(character["Force-powers"]))+"\n\n"
text7 = "**Equipment**: "+", ".join(character["Equipment"])+"\n**Credits**: "+str(character["Credits"])+"\n**Weapons**: "+", ".join(list(character["Weapons"]))+"\n"+divider
if bool(character["Obligations"]):
text8 = "**Obligations**: "+",".join(list(character["Obligations"]))
return name, text1+text2+"\n\n"+text3+divider+text4+"\n"+divider+text5+text6+text7+text8
def char_data(self,user : str,cmd : str):
user_character = self.bot.database["starwars characters"].find_one({"_id":user})
key = string.capwords(cmd.split(" ")[0])
cmd = cmd[len(key):]
if cmd == " ":
cmd = ""
elif cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
self.bot.log("Looking for "+self.bot.database_funcs.get_name(user)+"'s character")
if user_character != None:
self.bot.log("Found it! Looking for "+key+" in the data")
if key in user_character:
self.bot.log("Found it!")
if type(user_character[key]) is dict:
self.bot.log("It's a dictionary!")
if cmd == "":
self.bot.log("Retrieving data")
if key == "Weapons":
if bool(user_character[key]):
self.bot.log("Returning a list of weapons")
return ", ".join(list(user_character[key]))
else:
self.bot.log("The character doesn't have any weapons. Which is probably for the best. Like, who just walks around with weapons?")
return "There doesn't seem to be anything there..."
else:
return self.set_up_dict(user_character[key])
elif cmd[0] == "+":
self.bot.log("Gonna add something!!!")
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("Nope. That didn't happen")
return "Can't do that"
if (key == "Talents" or key == "Force-powers") and "," in cmd:
cmd = cmd.split(",")
while cmd[1][0] == " ":
cmd[1] = cmd[1][1:]
self.bot.log("Adding "+cmd[0]+" to "+key)
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key+"."+cmd[0] : cmd[1]}})
return cmd[0]+" added to "+key+" for " + user_character["Name"]
elif key == "Obligations" and "," in cmd:
cmd = cmd.split(",")
while cmd[1][0] == " ":
cmd[1] = cmd[1][1:]
self.bot.log("Adding "+cmd[0]+" to "+key)
try:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key+"."+cmd[0] : int(cmd[1])}})
except:
self.bot.log("Fucked that up")
return "Wrong data type"
return cmd[0]+" added to "+key+" for " + user_character["Name"]
elif key == "Weapons":
with open("gwendolyn/resources/star_wars/starwarstemplates.json", "r") as file_pointer:
templates = json.load(file_pointer)
new_weapon = templates["Weapon"]
self.bot.log("Adding "+cmd+" to "+key)
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key+"."+cmd : new_weapon}})
return cmd+" added to weapons for " + user_character["Name"]
else:
self.bot.log("That's not happening")
return "Can't add that"
elif cmd[0] == "-":
self.bot.log("Gonna subtract/remove something")
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("AAAAAAAAAAAA ")
return "Can't do that "
if key == "Talents" or key == "Force-powers" or key == "Weapons" or key == "Obligations":
self.bot.log("Trying to remove "+cmd+" from "+key)
if cmd in user_character[key]:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$unset": {cmd}})
self.bot.log("I did that")
return cmd+" removed from "+key+" from "+user_character["Name"]
else:
self.bot.log("Welp. I fucked that up")
return "Can't remove that"
else:
self.bot.log("Urgh!")
return "Can't remove that"
else:
self.bot.log("Looking up "+cmd+" in "+key)
if key == "Talents" or key == "Force-powers":
new_key = cmd
new_cmd = ""
else:
new_key = string.capwords(cmd.split(" ")[0])
new_cmd = cmd[len(new_key):]
look_up_result = self.look_up(user_character[key],new_key,new_cmd)
if type(look_up_result) is dict:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key : look_up_result}})
return "Changed " + user_character["Name"] + "'s " + key
else:
return look_up_result
else:
if cmd == "":
self.bot.log("Retrieving data")
if type(user_character[key]) is list:
return key+":\n"+", ".join(user_character[key])
else:
return user_character[key]
elif cmd[0] == '+':
self.bot.log("Adding")
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("Error message")
return "Can't do that"
if type(user_character[key]) is int:
try:
self.bot.log("Adding "+cmd+" to "+key)
self.bot.database["starwars characters"].update_one({"_id":user},
{"$inc": {key : int(cmd)}})
return "Added " + cmd + " to " + user_character["Name"] + "'s " + key
except:
self.bot.log("BITCH SANDWICH")
return "Can't add that"
elif type(user_character[key]) is list:
try:
self.bot.log("Adding "+cmd+" to "+key)
self.bot.database["starwars characters"].update_one({"_id":user},
{"$push": {key : cmd}})
return "Added " + cmd + " to " + user_character["Name"] + "'s " + key
except:
self.bot.log("tstststststs")
return "Can't add that"
else:
self.bot.log("Help")
return "Can't add that"
elif cmd[0] == '-':
self.bot.log("Removing/subtracting")
try:
cmd = cmd[1:]
while cmd[0] == ' ':
cmd = cmd[1:]
except:
self.bot.log("lalalala ")
return "Can't do that"
if type(user_character[key]) is int:
try:
self.bot.log("Subtracting "+cmd+" from "+key)
self.bot.database["starwars characters"].update_one({"_id":user},
{"$inc": {key : -int(cmd)}})
return "Subtracted " + cmd + " from " + user_character["Name"] + "'s " + key
except:
self.bot.log("Tried it. Didn't want to")
return "Can't remove that"
elif type(user_character[key]) is list:
try:
self.bot.log("removing "+cmd+" from "+key)
try:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$pull": {key : cmd}})
except:
self.bot.log("They can only remove stuff that's actually in the list")
return "Not in list"
return "Removed " + cmd + " from " + user_character["Name"] + "'s " + key
except:
self.bot.log("nah")
return "Can't remove that"
else:
self.bot.log("nyope")
return "Can't remove that"
else:
self.bot.log("Changing "+key+" to "+cmd)
if type(user_character[key]) is int:
try:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key : int(cmd)}})
except:
self.bot.log("I don't wanna tho")
return "Can't do that"
elif type(user_character[key]) is str:
self.bot.database["starwars characters"].update_one({"_id":user},
{"$set": {key : cmd}})
else:
self.bot.log("I don't wanna tho")
return "Can't do that"
return "Changed " + user_character["Name"] + "'s " + key +" to " + cmd
else:
self.bot.log(key+" isn't in there")
return "Couldn't find that data. Are you sure you spelled it correctly?"
else:
self.bot.log(user+" doesn't have a character")
return "You don't have a character. You can make one with /starwarscharacter"
def replace_spaces(self,cmd : str):
with_spaces = ["Specialization Trees","Wound Threshold","Strain Threshold","Defense - Ranged","Defense - Melee","Force Rating","Core Worlds","Outer Rim","Piloting - Planetary","Piloting - Space","Ranged - Heavy","Ranged - Light","Lightsaber Characteristic","Critical Injuries","Force Powers"]
without_spaces = ["Specialization-trees","Wound-threshold","Strain-threshold","Defense-ranged","Defense-melee","Force-rating","Core-worlds","Outer-rim","Piloting-planetary","Piloting-space","Ranged-heavy","Ranged-light","Lightsaber-characteristic","Critical-injuries","Force-powers"]
for i, value in enumerate(without_spaces):
cmd = cmd.replace(with_spaces[i],value)
return cmd
def replace_with_spaces(self,cmd : str):
with_spaces = ["Specialization Trees","Wound Threshold","Strain Threshold","Defense - Ranged","Defense - Melee","Force Rating","Core Worlds","Outer Rim","Piloting - Planetary","Piloting - Space","Ranged - Heavy","Ranged - light","Lightsaber Characteristic","Critical Injuries","Force Powers"]
without_spaces = ["Specialization-trees","Wound-threshold","Strain-threshold","Defense-ranged","Defense-melee","Force-rating","Core-worlds","Outer-rim","Piloting-planetary","Piloting-space","Ranged-heavy","Ranged-light","Lightsaber-characteristic","Critical-injuries","Force-powers"]
for i, value in enumerate(without_spaces):
cmd = cmd.replace(value,with_spaces[i])
return cmd
async def parse_char(self, ctx, parameters : str):
user = f"#{ctx.author.id}"
cmd = string.capwords(parameters.replace("+","+ ").replace("-","- ").replace(",",", "))
return_embed = False
cmd = self.replace_spaces(cmd)
user_character = self.bot.database["starwars characters"].find_one({"_id":user})
if cmd == " ":
cmd = ""
elif cmd != "":
while cmd[0] == " ":
cmd = cmd[1:]
if cmd == "":
break
if cmd == "":
if user_character != None:
title, text = self.character_sheet(user_character)
text = self.replace_with_spaces(text)
return_embed = True
else:
self.bot.log("Makin' a character for "+self.bot.database_funcs.get_name(user))
with open("gwendolyn/resources/star_wars/starwarstemplates.json", "r") as file_pointer:
templates = json.load(file_pointer)
new_char = templates["Character"]
new_char["_id"] = user
self.bot.database["starwars characters"].insert_one(new_char)
await ctx.send("Character for " + self.bot.database_funcs.get_name(user) + " created")
else:
if cmd == "Purge":
self.bot.log("Deleting "+self.bot.database_funcs.get_name(user)+"'s character")
self.bot.database["starwars characters"].delete_one({"_id":user})
await ctx.send("Character for " + self.bot.database_funcs.get_name(user) + " deleted")
else:
await ctx.send(self.replace_with_spaces(str(self.char_data(user,cmd))))
if return_embed:
embed = discord.Embed(title = title, description = text, colour=0xDEADBF)
await ctx.send(embed = embed)
def lightsaber_char(self,user : str):
user_character = self.bot.database["starwars characters"].find_one({"_id":user})
if user_character != None:
return user_character["Lightsaber-characteristic"]
def user_has_char(self,user : str):
user_character = self.bot.database["starwars characters"].find_one({"_id":user})
return user_character != None

72
gwendolyn/funcs/star_wars_funcs/star_wars_destiny.py
View File

@ -1,72 +0,0 @@
class StarWarsDestiny():
def __init__(self, bot):
self.bot = bot
def destiny_new(self, num : int):
self.bot.log("Creating a new destiny pool with "+str(num)+" players")
roll, dice_results = self.bot.star_wars.roll.roll(0,0,0,0,0,0,num)
roll = "".join(sorted(roll))
with open("gwendolyn/resources/star_wars/destinyPoints.txt","wt") as file_pointer:
file_pointer.write(roll)
return "Rolled for Destiny Points and got:\n"+self.bot.star_wars.roll.diceResultToEmoji(dice_results)+"\n"+self.bot.star_wars.roll.resultToEmoji(roll)
def destiny_use(self, user : str):
with open("gwendolyn/resources/star_wars/destinyPoints.txt","rt") as file_pointer:
points = file_pointer.read()
if user == "Nikolaj":
self.bot.log("Trying to use a dark side destiny point")
if 'B' in points:
points = points.replace("B","L",1)
points = "".join(sorted(points))
with open("gwendolyn/resources/star_wars/destinyPoints.txt","wt") as file_pointer:
file_pointer.write(points)
self.bot.log("Did it")
return "Used a dark side destiny point. Destiny pool is now:\n"+self.bot.star_wars.roll.resultToEmoji(points)
else:
self.bot.log("There were no dark side destiny points")
return "No dark side destiny points"
else:
self.bot.log("Trying to use a light side destiny point")
if 'L' in points:
points = points.replace("L","B",1)
points = "".join(sorted(points))
with open("gwendolyn/resources/star_wars/destinyPoints.txt","wt") as file_pointer:
file_pointer.write(points)
self.bot.log("Did it")
return "Used a light side destiny point. Destiny pool is now:\n"+self.bot.star_wars.roll.resultToEmoji(points)
else:
self.bot.log("There were no dark side destiny points")
return "No light side destiny points"
async def parse_destiny(self, ctx, cmd : str):
user = f"#{ctx.author.id}"
if cmd != "":
while cmd[0] == ' ':
cmd = cmd[1:]
if cmd == "":
break
if cmd == "":
self.bot.log("Retrieving destiny pool info")
with open("gwendolyn/resources/star_wars/destinyPoints.txt","rt") as file_pointer:
send_message = self.bot.star_wars.roll.resultToEmoji(file_pointer.read())
else:
commands = cmd.upper().split(" ")
if commands[0] == "N":
if len(commands) > 1:
send_message = self.destiny_new(int(commands[1]))
else:
send_message = "You need to give an amount of players"
elif commands[0] == "U":
send_message = self.destiny_use(user)
else:
send_message = "I didn't quite understand that"
message_list = send_message.split("\n")
await ctx.send(message_list[0])
if len(message_list) > 1:
for message_item in message_list[1:]:
await ctx.channel.send(message_item)

391
gwendolyn/funcs/star_wars_funcs/star_wars_roll.py
View File

@ -1,391 +0,0 @@
import random
import re
import string
import json
with open("gwendolyn/resources/star_wars/starwarsskills.json", "r") as f:
skill_data = json.load(f)
class StarWarsRoll():
def __init__(self, bot):
self.bot = bot
# Rolls the specified dice
def roll(self, abi : int = 1, prof : int = 0, dif : int = 3, cha : int = 0, boo : int = 0, setb : int = 0, force : int = 0):
result = ""
dice_result = []
for _ in range(abi):
choice = random.choice(["","S","S","SS","A","A","SA","AA"])
result += choice
dice_result.append("abi"+choice)
for _ in range(prof):
choice = random.choice(["","S","S","SS","SS","A","SA","SA","SA","AA","AA","R"])
result += choice
dice_result.append("prof"+choice)
for _ in range(dif):
choice = random.choice(["","F","FF","H","H","H","HH","FH"])
result += choice
dice_result.append("dif"+choice)
for _ in range(cha):
choice = random.choice(["","F","F","FF","FF","H","H","FH","FH","HH","HH","D"])
result += choice
dice_result.append("cha"+choice)
for _ in range(boo):
choice = random.choice(["","","S","SA","AA","A"])
result += choice
dice_result.append("boo"+choice)
for _ in range(setb):
choice = random.choice(["","","F","F","H","H"])
result += choice
dice_result.append("setb"+choice)
for _ in range (force):
choice = random.choice(["B","B","B","B","B","B","BB","L","L","LL","LL","LL"])
result += choice
dice_result.append("force"+choice)
return result, dice_result
# Lets dice cancel each other out
def simplify(self, result : str):
self.bot.log("Simplifying "+result)
simp = ""
success = (result.count('S') + result.count('R')) - (result.count('F') + result.count('D'))
advantage = result.count('A') - result.count('H')
result = re.sub("S|A|F|H","",result)
if success > 0:
for _ in range(success):
simp += "S"
elif success < 0:
for _ in range(abs(success)):
simp += "F"
if advantage > 0:
for _ in range(advantage):
simp += "A"
elif advantage < 0:
for _ in range(abs(advantage)):
simp += "H"
simp += result
return simp
# Returns emoji that symbolize the dice results
def dice_result_to_emoji(self, dice_results : list):
emoji = ""
for result in dice_results:
if result == "abiA":
emoji += "<:abil1a:695267684476125264> "
elif result == "abiSA":
emoji += "<:abil1a1s:695267684484513842> "
elif result == "abiS":
emoji += "<:abil1s:695267684514005013> "
elif result == "abiAA":
emoji += "<:abil2a:695267684547428352> "
elif result == "abiSS":
emoji += "<:abil2s:695267684761206914> "
elif result == "abi":
emoji += "<:abilbla:695267684660674602> "
elif result == "profA":
emoji += "<:prof1a:695267685361123338> "
elif result == "profSA":
emoji += "<:prof1a1s:695267685067653140> "
elif result == "profR":
emoji += "<:prof1r:695267685067522088> "
elif result == "profS":
emoji += "<:prof1s:695267684899881012> "
elif result == "profAA":
emoji += "<:prof2a:695267684996218982> "
elif result == "profSS":
emoji += "<:prof2s:695267684878647327> "
elif result == "prof":
emoji += "<:profbla:695267684698292235> "
elif result == "difF":
emoji += "<:dif1f:695267684924915804> "
elif result == "difH":
emoji += "<:dif1h:695267684908138506> "
elif result == "difFH":
emoji += "<:dif1h1f:695267684908269678> "
elif result == "difFF":
emoji += "<:dif2f:695267684924784680> "
elif result == "difHH":
emoji += "<:dif2h:695267685071585340> "
elif result == "dif":
emoji += "<:difbla:695267685000544276> "
elif result == "chaD":
emoji += "<:cha1d:695267684962533447> "
elif result == "chaF":
emoji += "<:cha1f:695267684601954346> "
elif result == "chaH":
emoji += "<:cha1h:695267685046681620> "
elif result == "chaFH":
emoji += "<:cha1h1f:695267685063327784> "
elif result == "chaFF":
emoji += "<:cha2f:695267684832641097> "
elif result == "chaHH":
emoji += "<:cha2h:695267684631183381> "
elif result == "cha":
emoji += "<:chabla:695267684895686787> "
elif result == "booA":
emoji += "<:boo1a:695267684975116329> "
elif result == "booSA":
emoji += "<:boo1a1s:695267684970922024> "
elif result == "booS":
emoji += "<:boo1s:695267684979441714> "
elif result == "booAA":
emoji += "<:boo2a:695267685100945488> "
elif result == "boo":
emoji += "<:boobla:695267684757012550> "
elif result == "setbF":
emoji += "<:set1f:695267685054939197> "
elif result == "setbH":
emoji += "<:set1h:695267685147082802> "
elif result == "setb":
emoji += "<:setbla:695267685151408169> "
elif result == "forceB":
emoji += "<:for1b:695267684593434677> "
elif result == "forceL":
emoji += "<:for1l:695267684606148640> "
elif result == "forceBB":
emoji += "<:for2b:695267684903944303> "
elif result == "forceLL":
emoji += "<:for2l:695267684992024626> "
return emoji
# Returns emoji that symbolize the results of the dice rolls
def result_to_emoji(self, result : str):
emoji = ""
for char in result:
if char == 'S':
emoji += "<:success:826026925280854026> "
elif char == 'A':
emoji += "<:advantage:826026925515604009> "
elif char == 'R':
emoji += "<:triumph:826026925319127070> "
elif char == 'F':
emoji += "<:failure:826026925288980511> "
elif char == 'H':
emoji += "<:threat:826026925280985108> "
elif char == 'D':
emoji += "<:despair:826026925272203294> "
elif char == 'L':
emoji += "<:light:826026925059211295>"
elif char == 'B':
emoji += "<:dark:826026925289373717>"
return emoji
# Converts emoji into letters
def emoji_to_result(self, emoji : str):
result = ""
for char in emoji:
if char == "<:light:691010089905029171>":
emoji += 'L'
if char == "<:dark:691010101901000852>":
emoji += 'B'
return result
# Returns emoji that symbolize the dice
def dice_to_emoji(self, dice : list):
emoji = ""
for _ in range(dice[0]):
emoji += "<:ability:690974213397282826> "
for _ in range(dice[1]):
emoji += "<:proficiency:690973435354153071> "
for _ in range(dice[2]):
emoji += "<:difficulty:690973992470708296> "
for _ in range(dice[3]):
emoji += "<:challenge:690973419906400306> "
for _ in range(dice[4]):
emoji += "<:boost:690972178216386561> "
for _ in range(dice[5]):
emoji += "<:setback:690972157890658415> "
for _ in range(dice[6]):
emoji += "<:force:690973451883774013> "
return emoji
# Rolls for obligation
def obligation_roll(self):
self.bot.log("Rolling for obligation")
data = self.bot.database["starwarscharacters"]
table = []
for character in data:
for obligation in data[character]["Obligations"]:
for _ in range(data[character]["Obligations"][obligation]):
table.append(data[character]["Name"]+", "+obligation)
while len(table) < 100:
table.append("Nothing")
return random.choice(table)
# Rolls for critical injury
async def crit_roll(self, ctx, addington : int):
difficulty_die = "<:difficulty:690973992470708296>"
setback_die = "<:setback:690972157890658415>"
boost_die = "<:boost:690972178216386561>"
roll = random.randint(1,100) + addington
injuries = [
"**Minor nick**: The target suffers 1 strain, "+difficulty_die] * 5 + [
"**Slowed down**: The target can only act during the last allied initiative slot this turn, "+difficulty_die] * 5 + [
"**Sudden Jolt**: The target drops whatever is in hand, "+difficulty_die] * 5 + [
"**Distracted**: The target cannot perform a Free maneuver during his next turn, "+difficulty_die] * 5 + [
"**Off-Balance**: The target adds "+setback_die+" to his next skill check, "+difficulty_die] * 5 + [
"**Discouraging Wound**: Flip one light side Destiny point to a dark side Destiny point (reverse if NPC), "+difficulty_die] * 5 + [
"**Stunned**: The target is staggered until the end of his next turn, "+difficulty_die] * 5 + [
"**Stinger**: Increase the difficulty of next check by one, "+difficulty_die] * 5 + [
"**Bowled Over**: The target is knocked prone and suffers 1 strain, "+difficulty_die+difficulty_die] * 5 + [
"**Head Ringer**: The target increases the difficulty of all Intellect and Cunning checks by one until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Fearsome Wound**: The target increases the difficulty of all Presence and Willpower checks by one until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Agonizing Wound**: The target increases the difficulty of all Brawn and Agility checks by one until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Slightly Dazed**: The target is disoriented until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Scattered Senses**: The target removes all "+boost_die+" from skill checks until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Hamstrung**: The target loses his free maneuver until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**Overpowered**: The target leaves himself open, and the attacker may immediately attempt another free attack agains him, using the exact same pool as the original, "+difficulty_die+difficulty_die] * 5 + [
"**Winded**: Until the end of the encounter, the target cannot voluntarily suffer strain to activate any abilities or gain additional maneuvers, "+difficulty_die+difficulty_die] * 5 + [
"**Compromised**: Incerase difficulty of all skill checks by one until the end of the encounter, "+difficulty_die+difficulty_die] * 5 + [
"**At the brink**: The target suffers 1 strain each time he performs an action, "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"**Crippled**: One of the target's limbs (selected by the GM) is crippled until healed or replaced. Increase difficulty of all checks that require use of that limb by one, "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"**Maimed**: One of the target's limbs (selected by the GM) is permanently lost. Unless the target has a cybernetic replacement, the target cannot perform actions that would require the use of that limb. All other actions gain "+setback_die+", "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"HI"] * 5 + [
"**Temporarily Lame**: Until this critical injury is healed, the target cannot perform more than one maneuver during his turn, "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"**Blinded**: The target can no longer see. Upgrade the difficulty of all checks twice. Upgrade the difficulty of perception checks three times, "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"**Knocked Senseless**: The target is staggered for the remainder of the encounter, "+difficulty_die+difficulty_die+difficulty_die] * 5 + [
"GI"] * 5 + [
"**Bleeding Out**: Every round, the target suffers 1 wound and 1 strain at the beginning of his turn. For every five wounds he suffers beyond his wound threshold, he suffers one additional critical injury. (If he suffers this one again, roll again), "+difficulty_die+difficulty_die+difficulty_die+difficulty_die] * 10 + [
"**The End is Nigh**: The target will die after the last initiative slot during the next round, "+difficulty_die+difficulty_die+difficulty_die+difficulty_die] * 10 + [
"**Dead**: U B Dead :("]
if roll >= len(injuries):
results = injuries[-1]
else:
results = injuries[roll]
if results == "HI":
characteristic = random.choice(["brawn"] * 3 + ["agility"] * 3 + ["intellect", "cunning", "presence"])
results = "**Horrific Injury**: Until this criticil injury is healed, treat the target's "+characteristic+" as if it's one lower, "+difficulty_die+difficulty_die+difficulty_die
if results == "GI":
characteristic = random.choice(["brawn"] * 3 + ["agility"] * 3 + ["intellect", "cunning", "presence"])
results = "**Gruesome Injury**: The target's "+characteristic+" is permanently one lower, "+difficulty_die+difficulty_die+difficulty_die+difficulty_die
send_message = "Roll: "+str(roll)+"\nInjury:\n"+results
message_list = send_message.split("\n")
await ctx.send(message_list[0])
if len(message_list) > 1:
for message_item in message_list[1:]:
await ctx.channel.send(message_item)
# Parses the command into something the other functions understand
async def parse_roll(self, ctx, cmd : str = ""):
user = f"#{ctx.author.id}"
cmd = re.sub(' +',' ',cmd.upper()) + " "
if cmd[0] == " ":
cmd = cmd[1:]
cmd = self.bot.star_wars.character.replaceSpaces(string.capwords(cmd))
commands = cmd.split(" ")
valid_command = False
if commands[0] == "":
roll_parameters = [1,0,3,0,0,0,0]
else:
roll_parameters = [0,0,0,0,0,0,0]
if string.capwords(commands[0]) == "Obligations":
send_message = self.obligation_roll()
elif string.capwords(commands[0]) in skill_data:
self.bot.log("Oh look! This guy has skills!")
if self.bot.star_wars.character.userHasChar(user):
self.bot.log("They have a character. That much we know")
skill_level = self.bot.star_wars.character.char_data(user,"Skills " + string.capwords(commands[0]))
if string.capwords(commands[0]) == "Lightsaber":
self.bot.log("The skill is lightsaber")
char_level = self.bot.star_wars.character.char_data(user,"Characteristics " + self.bot.star_wars.character.lightsaberChar(user))
else:
char_level = self.bot.star_wars.character.char_data(user,"Characteristics " + skill_data[string.capwords(commands[0])])
ability_dice = abs(char_level-skill_level)
proficiency_dice = min(skill_level,char_level)
commands = [str(ability_dice)] + [str(proficiency_dice)] + commands[1:]
self.bot.log("Converted skill to dice")
valid_command = True
else:
self.bot.log("Okay, no they don't i guess")
send_message = "You don't have a user. You can make one with /starwarscharacter"
elif string.capwords(commands[0]) in ["Ranged","Piloting"]:
self.bot.log("They fucked up writing the name of a ranged or piloting skill")
if string.capwords(commands[0]) == "Ranged":
send_message = "Did you mean \"Ranged - Heavy\" or \"Ranged - Light\""
else:
send_message = "Did you mean \"Piloting - Planetary\" or \"Piloting - Space\""
else:
valid_command = True
if valid_command:
self.bot.log("Converting commands to dice")
for i, command in enumerate(commands):
if command != "":
command = command.upper()
if command[0] == "A":
roll_parameters[0] = int(command.replace("A",""))
elif command[0] == "P":
roll_parameters[1] = int(command.replace("P",""))
elif command[0] == "D":
roll_parameters[2] = int(command.replace("D",""))
elif command[0] == "C":
roll_parameters[3] = int(command.replace("C",""))
elif command[0] == "B":
roll_parameters[4] = int(command.replace("B",""))
elif command[0] == "S":
roll_parameters[5] = int(command.replace("S",""))
elif command[0] == "F":
roll_parameters[6] = int(command.replace("F",""))
else:
roll_parameters[i] = int(command)
self.bot.log("Rolling "+str(roll_parameters))
roll_results, dice_results = self.roll(roll_parameters[0],roll_parameters[1],roll_parameters[2],roll_parameters[3],roll_parameters[4],roll_parameters[5],roll_parameters[6])
simplified = self.simplify(roll_results)
name = self.bot.star_wars.character.getChar_name(user)
self.bot.log("Returns results and simplified results")
if simplified == "":
send_message = name + " rolls: " + "\n" + self.dice_result_to_emoji(dice_results) + "\nEverything cancels out!"
else:
send_message = name + " rolls: " + "\n" + self.dice_result_to_emoji(dice_results) + "\n" + self.result_to_emoji(simplified)
message_list = send_message.split("\n")
await ctx.send(message_list[0])
if len(message_list) > 1:
for message_item in message_list[1:]:
if message_item == "":
self.bot.log("Tried to send empty message")
else:
await ctx.channel.send(message_item)