[Dúvida] ME AJUDEM A CONSERTAR O BOT PYTHON DE DISCORD

[LuciferusX]

ESTOU USANDO O CÓDIGO:

 

import discord
from discord.ext import commands
from PIL import Image, ImageDraw, ImageFont
import random

TOKEN = 'APAGUEI O TOKEN POR MOTIVOS DE SEGURANÇA'

from discord import Intents

intents = discord.Intents.all()
intents.members = True

bot = commands.Bot(command_prefix='/', intents=intents)

# Função para carregar a imagem do dado correspondente
def load_dice_image(dice_type):
    return Image.open(f'dado{dice_type}.png')

# Comando para rolar dados
@bot.command(name='roll')
async def roll(ctx, dice_notation="1d6"):
    # restante do código aqui

    # Definindo limites para a quantidade e tipo de dado
    dice_types = [4, 6, 8, 10, 12, 20]
    max_rolls = 10

    # Separando a quantidade de rolagens e o tipo de dado da notação
    rolls, dice_type = map(int, dice_notation.split('d'))

    # Verificando se a quantidade de rolagens e o tipo de dado estão dentro dos limites permitidos
    if rolls > max_rolls:
        await ctx.send(f"Desculpe, você não pode rolar mais do que {max_rolls} dados de uma vez.")
        return
    elif dice_type not in dice_types:
        await ctx.send(f"Desculpe, o tipo de dado {dice_type} não é permitido. Os tipos permitidos são: {dice_types}")
        return

    # Inicializando o valor total da rolagem
    total_roll = 0

    # Inicializando as imagens dos dados
    dice_images = []

    # Fazendo a rolagem para cada dado
    for i in range(rolls):
        # Rolando o dado e somando ao valor total
        roll_value = random.randint(1, dice_type)
        total_roll += roll_value

        # Adicionando a imagem correspondente ao dado rolado à lista de imagens
        dice_images.append(load_dice_image(dice_type))

        # Verificando se há vantagem ou desvantagem
    if 'v' in dice_notation:
        roll_values = []
        for i in range(rolls):
            roll_value = random.randint(1, dice_type)
            roll_value_with_advantage = max(roll_value, random.randint(1, dice_type))
            roll_values.append(roll_value_with_advantage)
        total_roll = sum(roll_values)
    elif 'd' in dice_notation:
        roll_values = []
        for i in range(rolls):
            roll_value = random.randint(1, dice_type)
            roll_value_with_disadvantage = min(roll_value, random.randint(1, dice_type))
            roll_values.append(roll_value_with_disadvantage)
        total_roll = sum(roll_values)
    else:
    # Fazendo a rolagem para cada dado
        for i in range(rolls):
            # Rolando o dado e somando ao valor total
            roll_value = random.randint(1, dice_type)
            total_roll += roll_value

            # Adicionando a imagem correspondente ao dado rolado à lista de imagens
            dice_images.append(load_dice_image(dice_type))

        # Verificando se o resultado é maior ou menor do que o máximo ou mínimo possível
        max_possible_roll = dice_type * rolls
        min_possible_roll = rolls
        if total_roll > max_possible_roll:
            total_roll = max_possible_roll
        elif total_roll < min_possible_roll:
            total_roll = min_possible_roll
    
        # Mostrando as imagens dos dados
        dice_images[0].save('dice_roll.png', save_all=True, append_images=dice_images[1:])

        # Editando as imagens dos dados com o número correspondente ao resultado da rolagem
        for i in range(rolls):
            # Obtendo a imagem correspondente ao dado
            dice_image = dice_images[i]

            # Obtendo as dimensões da imagem
            width, height = dice_image.size

            # Criando um objeto ImageDraw para desenhar na imagem
            draw = ImageDraw.Draw(dice_image)

            # Definindo o tamanho da fonte para o número
            font_size = int(width/3)

            # Definindo a fonte
            font = ImageFont.truetype('arial.ttf', font_size)

            # Desenhando o número no centro da imagem
            number = str(random.randint(1, dice_type))
            number_width, number_height = draw.textsize(number, font=font)
            x = int((width - number_width) / 2)
            y = int((height - number_height) / 2)
            draw.text((x, y), number, fill=(255, 255, 255), font=font)

            # Substituindo a imagem correspondente na lista de imagens dos dados
            dice_images[i] = dice_image

        # Salvando a imagem final da rolagem dos dados
        dice_images[0].save('dice_roll.png', save_all=True, append_images=dice_images[1:])

        with open('dice_roll.png', 'rb') as f:
            dice_roll_image = discord.File(f)

            # Enviando a imagem dos dados rolados
        await ctx.send(f"Resultado da rolagem: {roll_value}", file=dice_roll_image)

# Rodando o bot
bot.run('APAGUEI O TOKEN POR MOTIVOS DE SEGURANÇA')

 

 

BASICAMENTE A IDEIA ERA EU USAR UM "/ROLL 2D20", POR EXEMPLO, E ELE ENVIAR DUAS IMAGENS BASE (DADO20.PNG) COM UM NÚMERO CORRESPONDENTE AO RESULTADO SORTEADO, COMO O 14, POR EXEMPLO. NO ENTANTO, CASO EU TIVESSE ESCRITO "/ROLL 2D20 +2", POR EXEMPLO, ELE IRIA MANDAR 2 IMAGENS COM OS RESULTADOS INICIAIS (POR EXEMPLO: 12 E 5), CONSIDERAR APENAS O MAIOR, EM CASO DE VANTAGEM OU O MENOR, EM CASO DE DESVANTAGEM. COMO "+2" É VANTAGEM, ERA PARA ELE CONSIDERAR O 12 DENTRE AS DUAS IMAGENS E ENVIAR A MENSAGEM "CONSIDERANDO A VANTAGEM, O RESULTADO FINAL É 14)... MAS ELE SIMPLESMENTE NÃO RESPONDE, AO PASSO QUE NÃO APRESENTA ERRO ALGUM... O QUE POSSO FAZER? PODERIAM REFAZER O CÓDIGO PARA MIM DE MODO QUE A BIBLIOTECA "PIL" (PILLOW) MODIFIQUE A IMAGEM COM BASE NO SORTEIO E DEPOIS APAREÇA ESTA MENSAGEM DE TEXTO? ABRAÇO, MUITO OBRIGADO! ESPERO QUE MEU BOT RESPONDA A ALGUM COMANDO...


 

[LuciferusX]

ESTOU TENTANDO MODIFICAR E FICOU ASSIM:

 

import discord
from discord.ext import commands
import random
import re
import asyncio
from gtts import gTTS
from io import BytesIO
from PIL import Image, ImageDraw, ImageFont
import playsound
import os

intents = discord.Intents.all()
bot = commands.Bot(command_prefix='/', intents=intents)

# Defining the font to be used by Pillow
font = ImageFont.truetype('arial.ttf', size=40)

# Function to get the appropriate dice image based on the number of sides
def get_dice_image(num_sides):
    return Image.open(f"dado{num_sides}.png")

# Function to roll the dice and return the result
def roll_dice(num_dice, num_sides, modifier=0):
    rolls_list = []
    for i in range(num_dice):
        rolls_list.append(random.randint(1, num_sides))

    if modifier > 0:
        rolls_str = " + ".join([str(roll) for roll in rolls_list]) + f" + {modifier}"
    elif modifier < 0:
        rolls_str = " - ".join([str(roll) for roll in rolls_list]) + f" - {abs(modifier)}"
    else:
        rolls_str = ", ".join([str(roll) for roll in rolls_list])

    result = sum(rolls_list) + modifier

    return rolls_str, result

# Event that runs when the bot is ready
@bot.event
async def on_ready():
    print("Bot is ready!")

# Command to roll the dice
@bot.command()
async def roll(ctx, dice_str: str):
    try:
        num_dice, num_sides = map(int, dice_str.split('d'))
    except Exception:
        await ctx.send("Formato inválido. Use o formato NdN, por exemplo 2d6.")
        return

    if num_sides not in [4, 6, 8, 10, 12, 20]:
        await ctx.send("Não existe um dado com esse número de lados.")
        return

    if num_dice > 10:
        await ctx.send("Não é possível rolar mais do que 10 dados de uma só vez.")
        return

    dice_parts = re.match(r'(\d+)d(\d+)\s*([+-]\s*\d+)?', dice_str)
    if not dice_parts:
        await ctx.send("Formato inválido. Use o formato NdN [+/- X], por exemplo 2d6 +3.")
        return

    num_dice = int(dice_parts.group(1))
    num_sides = int(dice_parts.group(2))

    modifier_str = dice_parts.group(3)
    if modifier_str:
        modifier = int(modifier_str.replace(' ', ''))
    else:
        modifier = 0

  # Seguro pois eval() é perigoso

    if num_dice * num_sides > 1000:
        await ctx.send("Não é possível rolar mais do que 1000 dados de uma só vez.")
        return

    rolls_str, result = roll_dice(num_dice, num_sides, modifier)
    image = get_dice_image(num_sides)
    draw = ImageDraw.Draw(image)
    draw.text((10, 10), rolls_str, font=font, fill=(255, 255, 255))
    image_bytes = BytesIO()
    image.save(image_bytes, format='PNG')
    image_bytes.seek(0)
    await ctx.send(file=discord.File(fp=image_bytes, filename='dice.png'))

    if result > 0:
        message = f"Você rolou {rolls_str} + {modifier} e obteve um resultado de **{result}**!"
    elif result < 0:
        message = f"Você rolou {rolls_str} - {abs(modifier)} e obteve um resultado de **{result}**!"
    else:
        message = f"Você rolou {rolls_str} e obteve um resultado de **{result}**!"

    await ctx.send(message)

    if result == num_dice * num_sides:
        await ctx.send("CRÍTICO!")
        voice_channel = ctx.author.voice.channel
        voice_client = await voice_channel.connect()
        voice_client.play(discord.FFmpegPCMAudio("critico.mp3"))
        while voice_client.is_playing():
            await asyncio.sleep(1)
        await voice_client.disconnect()
    elif result == num_dice:
        await ctx.send("FALHA CRÍTICA!")
        voice_channel = ctx.author.voice.channel
        voice_client = await voice_channel.connect()
        voice_client.play(discord.FFmpegPCMAudio("falha_critica.mp3"))
        while voice_client.is_playing():
            await asyncio.sleep(1)
        await voice_client.disconnect()
    else:
        playsound.playsound("rolldice.mp3")

#TOKEN
bot.run('MTA5NzEzMDMzMjkyMDIyNTc5Mw.GmiGaT.8d4igrWUA7u-k93EMOg9qfpUIV4y5OcI2nl7L8')



OS SONS VOLTARAM. ELE VOLTOU A ROLAR E A INDICAR O RESULTADO. MAS ELE ESTÁ SOMANDO OS VALORES DOS DADOS QUANDO EU JOGO MAIS DE UM. E ELE NÃO ESTÁ APLICANDO O MODIFICADOR (VANTAGEM OU DESVANTAGEM, COMO +1, +2, +3... -1, -2, -3...). E, QUANDO ROLO MAIS DE UM DADO, ELE ESTÁ ESCREVENDO OS RESULTADOS EM UMA ÚNICA IMAGEM COM A BIBLIOTECA PIL.