1518 lines
64 KiB
Python
1518 lines
64 KiB
Python
import discord
|
|
from discord.ext import commands
|
|
from discord import ui # Add ui for LayoutView
|
|
import json
|
|
import os
|
|
import asyncio
|
|
import random
|
|
import math
|
|
import traceback # Import traceback for detailed error logging
|
|
from typing import Dict, List, Optional, Union, Set
|
|
|
|
# File paths for JSON data
|
|
LEVELS_FILE = "levels_data.json"
|
|
LEVEL_ROLES_FILE = "level_roles.json"
|
|
RESTRICTED_CHANNELS_FILE = "level_restricted_channels.json"
|
|
LEVEL_CONFIG_FILE = "level_config.json"
|
|
|
|
# Default XP settings
|
|
DEFAULT_XP_PER_MESSAGE = 15
|
|
DEFAULT_XP_PER_REACTION = 5
|
|
DEFAULT_XP_COOLDOWN = 30 # seconds
|
|
DEFAULT_REACTION_COOLDOWN = 30 # seconds
|
|
DEFAULT_LEVEL_MULTIPLIER = 35 # XP needed per level = level * multiplier
|
|
|
|
|
|
class LevelingCog(commands.Cog):
|
|
def __init__(self, bot: commands.Bot):
|
|
self.bot = bot
|
|
if not self.bot:
|
|
print("DEBUG: Bot instance is None in LevelingCog.__init__")
|
|
self.user_data = (
|
|
{}
|
|
) # {user_id: {"xp": int, "level": int, "last_message_time": float}}
|
|
self.level_roles = {} # {guild_id: {level: role_id}}
|
|
self.restricted_channels = set() # Set of channel IDs where XP gain is disabled
|
|
self.xp_cooldowns = {} # {user_id: last_xp_time}
|
|
self.reaction_cooldowns = {} # {user_id: last_reaction_time}
|
|
|
|
# Configuration settings
|
|
self.config = {
|
|
"xp_per_message": DEFAULT_XP_PER_MESSAGE,
|
|
"xp_per_reaction": DEFAULT_XP_PER_REACTION,
|
|
"message_cooldown": DEFAULT_XP_COOLDOWN,
|
|
"reaction_cooldown": DEFAULT_REACTION_COOLDOWN,
|
|
"reaction_xp_enabled": True,
|
|
"default_level_notifs_enabled": False, # New setting: level notifications disabled by default
|
|
}
|
|
|
|
# Load existing data
|
|
self.load_user_data()
|
|
self.load_level_roles()
|
|
self.load_restricted_channels()
|
|
self.load_config()
|
|
|
|
def load_user_data(self):
|
|
"""Load user XP and level data from JSON file"""
|
|
if os.path.exists(LEVELS_FILE):
|
|
try:
|
|
with open(LEVELS_FILE, "r", encoding="utf-8") as f:
|
|
# Convert string keys (from JSON) back to integers
|
|
data = json.load(f)
|
|
self.user_data = {}
|
|
for k, v in data.items():
|
|
user_id = int(k)
|
|
# Ensure 'level_notifs_enabled' is present with default if missing
|
|
if "level_notifs_enabled" not in v:
|
|
v["level_notifs_enabled"] = self.config[
|
|
"default_level_notifs_enabled"
|
|
]
|
|
self.user_data[user_id] = v
|
|
print(f"Loaded level data for {len(self.user_data)} users")
|
|
except Exception as e:
|
|
print(f"Error loading level data: {e}")
|
|
traceback.print_exc()
|
|
|
|
def save_user_data(self):
|
|
"""Save user XP and level data to JSON file"""
|
|
try:
|
|
# Convert int keys to strings for JSON serialization
|
|
serializable_data = {str(k): v for k, v in self.user_data.items()}
|
|
with open(LEVELS_FILE, "w", encoding="utf-8") as f:
|
|
json.dump(serializable_data, f, indent=4, ensure_ascii=False)
|
|
except Exception as e:
|
|
print(f"Error saving level data: {e}")
|
|
traceback.print_exc()
|
|
|
|
def load_level_roles(self):
|
|
"""Load level role configuration from JSON file"""
|
|
if os.path.exists(LEVEL_ROLES_FILE):
|
|
try:
|
|
with open(LEVEL_ROLES_FILE, "r", encoding="utf-8") as f:
|
|
# Convert string keys (from JSON) back to integers
|
|
data = json.load(f)
|
|
# Convert nested dictionaries with string keys to integers
|
|
self.level_roles = {}
|
|
for guild_id_str, roles_dict in data.items():
|
|
guild_id = int(guild_id_str)
|
|
self.level_roles[guild_id] = {}
|
|
|
|
# Process each level's role data
|
|
for level_str, role_data in roles_dict.items():
|
|
level = int(level_str)
|
|
|
|
# Check if this is a gendered role entry
|
|
if isinstance(role_data, dict):
|
|
# Handle gendered roles
|
|
self.level_roles[guild_id][level] = {}
|
|
for gender, role_id_str in role_data.items():
|
|
self.level_roles[guild_id][level][gender] = int(
|
|
role_id_str
|
|
)
|
|
else:
|
|
# Handle regular roles
|
|
self.level_roles[guild_id][level] = int(role_data)
|
|
|
|
print(f"Loaded level roles for {len(self.level_roles)} guilds")
|
|
except Exception as e:
|
|
print(f"Error loading level roles: {e}")
|
|
traceback.print_exc()
|
|
|
|
def save_level_roles(self):
|
|
"""Save level role configuration to JSON file"""
|
|
try:
|
|
# Convert int keys to strings for JSON serialization (for both guild_id and level)
|
|
serializable_data = {}
|
|
for guild_id, roles_dict in self.level_roles.items():
|
|
serializable_data[str(guild_id)] = {}
|
|
|
|
# Handle both regular and gendered roles
|
|
for level, role_data in roles_dict.items():
|
|
if isinstance(role_data, dict):
|
|
# Handle gendered roles
|
|
serializable_data[str(guild_id)][str(level)] = {
|
|
gender: str(role_id)
|
|
for gender, role_id in role_data.items()
|
|
}
|
|
else:
|
|
# Handle regular roles
|
|
serializable_data[str(guild_id)][str(level)] = str(role_data)
|
|
|
|
with open(LEVEL_ROLES_FILE, "w", encoding="utf-8") as f:
|
|
json.dump(serializable_data, f, indent=4, ensure_ascii=False)
|
|
except Exception as e:
|
|
print(f"Error saving level roles: {e}")
|
|
traceback.print_exc()
|
|
|
|
def load_restricted_channels(self):
|
|
"""Load restricted channels from JSON file"""
|
|
if os.path.exists(RESTRICTED_CHANNELS_FILE):
|
|
try:
|
|
with open(RESTRICTED_CHANNELS_FILE, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
# Convert list to set of integers
|
|
self.restricted_channels = set(
|
|
int(channel_id) for channel_id in data
|
|
)
|
|
print(f"Loaded {len(self.restricted_channels)} restricted channels")
|
|
except Exception as e:
|
|
print(f"Error loading restricted channels: {e}")
|
|
traceback.print_exc()
|
|
|
|
def save_restricted_channels(self):
|
|
"""Save restricted channels to JSON file"""
|
|
try:
|
|
# Convert set to list of strings for JSON serialization
|
|
serializable_data = [
|
|
str(channel_id) for channel_id in self.restricted_channels
|
|
]
|
|
with open(RESTRICTED_CHANNELS_FILE, "w", encoding="utf-8") as f:
|
|
json.dump(serializable_data, f, indent=4, ensure_ascii=False)
|
|
except Exception as e:
|
|
print(f"Error saving restricted channels: {e}")
|
|
traceback.print_exc()
|
|
|
|
def load_config(self):
|
|
"""Load leveling configuration from JSON file"""
|
|
if os.path.exists(LEVEL_CONFIG_FILE):
|
|
try:
|
|
with open(LEVEL_CONFIG_FILE, "r", encoding="utf-8") as f:
|
|
data = json.load(f)
|
|
# Update config with saved values, keeping defaults for missing keys
|
|
for key, value in data.items():
|
|
if key in self.config:
|
|
self.config[key] = value
|
|
print(f"Loaded leveling configuration")
|
|
except Exception as e:
|
|
print(f"Error loading leveling configuration: {e}")
|
|
traceback.print_exc()
|
|
|
|
def save_config(self):
|
|
"""Save leveling configuration to JSON file"""
|
|
try:
|
|
with open(LEVEL_CONFIG_FILE, "w", encoding="utf-8") as f:
|
|
json.dump(self.config, f, indent=4, ensure_ascii=False)
|
|
except Exception as e:
|
|
print(f"Error saving leveling configuration: {e}")
|
|
traceback.print_exc()
|
|
|
|
def calculate_level(self, xp: int) -> int:
|
|
"""Calculate level based on XP"""
|
|
# Level formula: level = sqrt(xp / multiplier)
|
|
return int(math.sqrt(xp / DEFAULT_LEVEL_MULTIPLIER))
|
|
|
|
def calculate_xp_for_level(self, level: int) -> int:
|
|
"""Calculate XP required for a specific level"""
|
|
return level * level * DEFAULT_LEVEL_MULTIPLIER
|
|
|
|
def get_user_data(self, user_id: int) -> Dict:
|
|
"""Get user data with defaults if not set"""
|
|
if user_id not in self.user_data:
|
|
self.user_data[user_id] = {
|
|
"xp": 0,
|
|
"level": 0,
|
|
"last_message_time": 0,
|
|
"level_notifs_enabled": self.config["default_level_notifs_enabled"],
|
|
}
|
|
return self.user_data[user_id]
|
|
|
|
async def add_xp(
|
|
self, user_id: int, guild_id: int, xp_amount: int = DEFAULT_XP_PER_MESSAGE
|
|
) -> Optional[int]:
|
|
"""
|
|
Add XP to a user and return new level if leveled up, otherwise None
|
|
"""
|
|
user_data = self.get_user_data(user_id)
|
|
current_level = user_data["level"]
|
|
|
|
# Add XP
|
|
user_data["xp"] += xp_amount
|
|
|
|
# Calculate new level
|
|
new_level = self.calculate_level(user_data["xp"])
|
|
user_data["level"] = new_level
|
|
|
|
# Save changes
|
|
self.save_user_data()
|
|
|
|
# Return new level if leveled up, otherwise None
|
|
if new_level > current_level:
|
|
# Check if there's a role to assign for this level in this guild
|
|
await self.assign_level_role(user_id, guild_id, new_level)
|
|
return new_level
|
|
return None
|
|
|
|
async def assign_level_role(self, user_id: int, guild_id: int, level: int) -> bool:
|
|
"""
|
|
Assign role based on user level
|
|
Returns True if role was assigned, False otherwise
|
|
"""
|
|
# Check if guild has level roles configured
|
|
if guild_id not in self.level_roles:
|
|
return False
|
|
|
|
# Get the guild object
|
|
guild = self.bot.get_guild(guild_id)
|
|
if not guild:
|
|
print(f"DEBUG: Guild {guild_id} not found in assign_level_role")
|
|
return False
|
|
|
|
# Get the member object
|
|
member = guild.get_member(user_id)
|
|
if not member:
|
|
print(
|
|
f"DEBUG: Member {user_id} not found in guild {guild_id} in assign_level_role"
|
|
)
|
|
return False
|
|
|
|
# Find the highest role that matches the user's level
|
|
highest_matching_level = 0
|
|
highest_role_id = None
|
|
|
|
# Check if we need to handle gendered roles
|
|
gender = None
|
|
|
|
# Check if the user has pronoun roles
|
|
for role in member.roles:
|
|
role_name_lower = role.name.lower()
|
|
if "he/him" in role_name_lower:
|
|
gender = "male"
|
|
break
|
|
elif "she/her" in role_name_lower:
|
|
gender = "female"
|
|
break
|
|
|
|
# Process level roles
|
|
for role_level, role_data in self.level_roles[guild_id].items():
|
|
if role_level <= level and role_level > highest_matching_level:
|
|
highest_matching_level = role_level
|
|
|
|
# Handle gendered roles if available
|
|
if isinstance(role_data, dict) and gender in role_data:
|
|
highest_role_id = role_data[gender]
|
|
elif (
|
|
isinstance(role_data, dict)
|
|
and "male" in role_data
|
|
and "female" in role_data
|
|
):
|
|
# If we have gendered roles but no gender preference, use male as default
|
|
highest_role_id = role_data["male"]
|
|
else:
|
|
# Regular role ID
|
|
highest_role_id = role_data
|
|
|
|
if highest_role_id:
|
|
# Get the role object
|
|
role = guild.get_role(highest_role_id)
|
|
if not role:
|
|
print(
|
|
f"DEBUG: Role {highest_role_id} not found in guild {guild_id} in assign_level_role"
|
|
)
|
|
return False
|
|
if role and role not in member.roles:
|
|
try:
|
|
# Remove any other level roles
|
|
roles_to_remove = []
|
|
|
|
for role_level, role_data in self.level_roles[guild_id].items():
|
|
# Handle both regular and gendered roles
|
|
if isinstance(role_data, dict):
|
|
# For gendered roles, check all gender variants
|
|
for gender_role_id in role_data.values():
|
|
if gender_role_id != highest_role_id:
|
|
other_role = guild.get_role(gender_role_id)
|
|
if other_role and other_role in member.roles:
|
|
roles_to_remove.append(other_role)
|
|
elif role_data != highest_role_id:
|
|
other_role = guild.get_role(role_data)
|
|
if other_role and other_role in member.roles:
|
|
roles_to_remove.append(other_role)
|
|
|
|
if roles_to_remove:
|
|
await member.remove_roles(
|
|
*roles_to_remove, reason="Level role update"
|
|
)
|
|
|
|
# Add the new role
|
|
await member.add_roles(role, reason=f"Reached level {level}")
|
|
return True
|
|
except discord.Forbidden:
|
|
print(f"Missing permissions to assign roles in guild {guild_id}")
|
|
except Exception as e:
|
|
print(f"Error assigning level role: {e}")
|
|
traceback.print_exc()
|
|
|
|
return False
|
|
|
|
@commands.Cog.listener()
|
|
async def on_message(self, message: discord.Message):
|
|
"""Event listener for messages to award XP"""
|
|
# Ignore bot messages
|
|
if message.author.bot:
|
|
return
|
|
|
|
# Ignore DM messages (leveling is only for guilds)
|
|
if not message.guild:
|
|
return
|
|
|
|
# Ignore messages in restricted channels
|
|
if message.channel.id in self.restricted_channels:
|
|
return
|
|
|
|
# Check cooldown
|
|
user_id = message.author.id
|
|
current_time = message.created_at.timestamp()
|
|
|
|
if user_id in self.xp_cooldowns:
|
|
time_diff = current_time - self.xp_cooldowns[user_id]
|
|
if time_diff < self.config["message_cooldown"]:
|
|
return # Still on cooldown
|
|
|
|
# Update cooldown
|
|
self.xp_cooldowns[user_id] = current_time
|
|
|
|
# Add XP with random variation (base ±5 XP)
|
|
base_xp = self.config["xp_per_message"]
|
|
xp_amount = random.randint(max(1, base_xp - 5), base_xp + 5)
|
|
new_level = await self.add_xp(user_id, message.guild.id, xp_amount)
|
|
|
|
# If user leveled up, send a message if notifications are enabled for them
|
|
if new_level:
|
|
user_data = self.get_user_data(user_id)
|
|
if user_data.get(
|
|
"level_notifs_enabled", self.config["default_level_notifs_enabled"]
|
|
):
|
|
try:
|
|
await message.channel.send(
|
|
f"🎉 Congratulations {message.author.mention}! You've reached level **{new_level}**!",
|
|
delete_after=10, # Delete after 10 seconds
|
|
)
|
|
except discord.Forbidden:
|
|
pass # Ignore if we can't send messages
|
|
|
|
@commands.hybrid_group(name="level", description="Leveling system commands")
|
|
async def level(self, ctx: commands.Context):
|
|
"""Leveling system commands"""
|
|
if ctx.invoked_subcommand is None:
|
|
await ctx.send_help(ctx.command)
|
|
|
|
@level.command(name="check", description="Check your current level and XP")
|
|
async def level_check(self, ctx: commands.Context, member: discord.Member = None):
|
|
"""Check your current level and XP or another member's"""
|
|
target = member or ctx.author
|
|
if not target:
|
|
print("DEBUG: Target member is None in level_check")
|
|
await ctx.send("Error: Could not determine target member.")
|
|
return
|
|
user_data = self.get_user_data(target.id)
|
|
|
|
level = user_data["level"]
|
|
xp = user_data["xp"]
|
|
|
|
# Calculate XP needed for next level
|
|
next_level = level + 1
|
|
xp_needed = self.calculate_xp_for_level(next_level)
|
|
xp_current = xp - self.calculate_xp_for_level(level)
|
|
xp_required = xp_needed - self.calculate_xp_for_level(level)
|
|
|
|
# Create progress bar (20 characters wide)
|
|
progress = xp_current / xp_required
|
|
progress_bar_length = 20
|
|
filled_length = int(progress_bar_length * progress)
|
|
bar = "█" * filled_length + "░" * (progress_bar_length - filled_length)
|
|
|
|
class LevelCheckView(ui.LayoutView):
|
|
def __init__(
|
|
self,
|
|
target_member: discord.Member,
|
|
level: int,
|
|
xp: int,
|
|
xp_needed: int,
|
|
next_level: int,
|
|
bar: str,
|
|
progress_percent: int,
|
|
):
|
|
super().__init__()
|
|
|
|
# Debug logging for parameters
|
|
if not target_member:
|
|
print("DEBUG: target_member is None in LevelCheckView.__init__")
|
|
|
|
# Main container for all elements, providing the accent color
|
|
main_container = ui.Container(accent_colour=None)
|
|
if main_container is None:
|
|
raise AssertionError(
|
|
"ui.Container returned None in LevelCheckView; ensure accent_colour is valid"
|
|
)
|
|
self.add_item(main_container) # Add the main container to the view
|
|
|
|
# Prepare thumbnail accessory
|
|
thumbnail_accessory = None
|
|
if target_member.display_avatar:
|
|
thumbnail_accessory = ui.Thumbnail(
|
|
media=target_member.display_avatar.url,
|
|
description="User Avatar",
|
|
)
|
|
|
|
# Section to hold the user's name and level/XP, with the thumbnail as accessory
|
|
# This section will be added to the main_container
|
|
user_info_section = ui.Section(accessory=thumbnail_accessory)
|
|
if user_info_section is None:
|
|
raise AssertionError("ui.Section returned None in LevelCheckView")
|
|
main_container.add_item(user_info_section)
|
|
|
|
# Add text components to the user_info_section
|
|
name_display = ui.TextDisplay(
|
|
f"**{target_member.display_name}'s Level**"
|
|
)
|
|
if name_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for name in LevelCheckView"
|
|
)
|
|
user_info_section.add_item(name_display)
|
|
|
|
level_display = ui.TextDisplay(
|
|
f"**Level:** {level}\n**XP:** {xp} / {xp_needed}"
|
|
)
|
|
if level_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for level info in LevelCheckView"
|
|
)
|
|
user_info_section.add_item(level_display)
|
|
|
|
# Add remaining components directly to the main_container
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError("ui.Separator returned None in LevelCheckView")
|
|
main_container.add_item(separator)
|
|
|
|
progress_text = ui.TextDisplay(
|
|
f"**Progress to Level {next_level}:**\n[{bar}] {progress_percent}%"
|
|
)
|
|
if progress_text is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None in LevelCheckView"
|
|
)
|
|
main_container.add_item(progress_text)
|
|
|
|
try:
|
|
view = LevelCheckView(
|
|
target, level, xp, xp_needed, next_level, bar, int(progress * 100)
|
|
)
|
|
await ctx.send(view=view)
|
|
except Exception as e:
|
|
print(f"Error creating level check view: {e}")
|
|
traceback.print_exc()
|
|
await ctx.send(
|
|
"❌ An error occurred while creating the level display. Please check the console for details."
|
|
)
|
|
|
|
@level.command(
|
|
name="leaderboard", description="Show the server's level leaderboard"
|
|
)
|
|
async def leaderboard_command(self, ctx: commands.Context):
|
|
"""Show the server's level leaderboard"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
# Get all members in the guild
|
|
guild_members = {member.id: member for member in ctx.guild.members}
|
|
|
|
# Filter user_data to only include members in this guild
|
|
guild_data = {}
|
|
for user_id, data in self.user_data.items():
|
|
if user_id in guild_members:
|
|
guild_data[user_id] = data
|
|
|
|
# Sort by XP (descending)
|
|
sorted_data = sorted(guild_data.items(), key=lambda x: x[1]["xp"], reverse=True)
|
|
|
|
class LeaderboardView(ui.LayoutView):
|
|
def __init__(
|
|
self,
|
|
guild_name: str,
|
|
sorted_leaderboard_data: list,
|
|
guild_members_dict: dict,
|
|
):
|
|
super().__init__()
|
|
|
|
# Main container for all elements, providing the accent color
|
|
main_container = ui.Container(accent_colour=discord.Colour.gold())
|
|
if main_container is None:
|
|
raise AssertionError(
|
|
"ui.Container returned None in LeaderboardView; ensure accent_colour is valid"
|
|
)
|
|
self.add_item(main_container) # Add the main container to the view
|
|
|
|
title_display = ui.TextDisplay(f"**{guild_name} Level Leaderboard**")
|
|
if title_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for title in LeaderboardView"
|
|
)
|
|
main_container.add_item(title_display)
|
|
|
|
sep = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if sep is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None in LeaderboardView"
|
|
)
|
|
main_container.add_item(sep)
|
|
|
|
if not sorted_leaderboard_data:
|
|
empty_display = ui.TextDisplay("The leaderboard is empty!")
|
|
if empty_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for empty message in LeaderboardView"
|
|
)
|
|
main_container.add_item(empty_display)
|
|
else:
|
|
for i, (user_id, data) in enumerate(
|
|
sorted_leaderboard_data[:10], 1
|
|
):
|
|
member = guild_members_dict.get(user_id)
|
|
if not member:
|
|
continue
|
|
|
|
# Each user's entry gets its own section and is added to the main_container
|
|
user_section = ui.Section(accessory=None)
|
|
if user_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None in LeaderboardView"
|
|
)
|
|
main_container.add_item(user_section)
|
|
|
|
# Add text components to the user_section
|
|
rank_display = ui.TextDisplay(f"**{i}. {member.display_name}**")
|
|
if rank_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for rank in LeaderboardView"
|
|
)
|
|
user_section.add_item(rank_display)
|
|
|
|
level_display = ui.TextDisplay(
|
|
f"Level: {data['level']} | XP: {data['xp']}"
|
|
)
|
|
if level_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for level in LeaderboardView"
|
|
)
|
|
user_section.add_item(level_display)
|
|
|
|
# Add separator to the main_container
|
|
if i < len(sorted_leaderboard_data[:10]): # not the last row
|
|
separator = ui.Separator(
|
|
spacing=discord.SeparatorSpacing.small
|
|
)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None between rows in LeaderboardView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
try:
|
|
view = LeaderboardView(ctx.guild.name, sorted_data, guild_members)
|
|
|
|
# Double-check the view is dispatchable and properly constructed
|
|
if view is None:
|
|
return await ctx.send(
|
|
"❌ Failed to build leaderboard layout. Please try again."
|
|
)
|
|
|
|
# Send the view
|
|
await ctx.send(view=view)
|
|
except Exception as e:
|
|
print(f"Error creating leaderboard view: {e}")
|
|
traceback.print_exc()
|
|
await ctx.send(
|
|
"❌ An error occurred while creating the leaderboard. Please check the console for details."
|
|
)
|
|
|
|
@level.command(
|
|
name="register_role", description="Register a role for a specific level"
|
|
)
|
|
@commands.has_permissions(manage_roles=True)
|
|
async def register_level_role(
|
|
self, ctx: commands.Context, level: int, role: discord.Role
|
|
):
|
|
"""Register a role to be assigned at a specific level"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
if level < 1:
|
|
await ctx.send("Level must be at least 1.")
|
|
return
|
|
|
|
# Initialize guild in level_roles if not exists
|
|
if ctx.guild.id not in self.level_roles:
|
|
self.level_roles[ctx.guild.id] = {}
|
|
|
|
# Register the role
|
|
self.level_roles[ctx.guild.id][level] = role.id
|
|
self.save_level_roles()
|
|
|
|
await ctx.send(f"✅ Role {role.mention} will now be assigned at level {level}.")
|
|
|
|
@level.command(name="remove_role", description="Remove a level role registration")
|
|
@commands.has_permissions(manage_roles=True)
|
|
async def remove_level_role(self, ctx: commands.Context, level: int):
|
|
"""Remove a level role registration"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
if (
|
|
ctx.guild.id not in self.level_roles
|
|
or level not in self.level_roles[ctx.guild.id]
|
|
):
|
|
await ctx.send("No role is registered for this level.")
|
|
return
|
|
|
|
# Remove the role registration
|
|
del self.level_roles[ctx.guild.id][level]
|
|
self.save_level_roles()
|
|
|
|
await ctx.send(f"✅ Level {level} role registration has been removed.")
|
|
|
|
@level.command(name="list_roles", description="List all registered level roles")
|
|
async def list_level_roles(self, ctx: commands.Context):
|
|
"""List all registered level roles for this server"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
if ctx.guild.id not in self.level_roles or not self.level_roles[ctx.guild.id]:
|
|
await ctx.send("No level roles are registered for this server.")
|
|
return
|
|
|
|
class ListLevelRolesView(ui.LayoutView):
|
|
def __init__(self, guild: discord.Guild, level_roles_data: dict):
|
|
super().__init__()
|
|
|
|
main_container = ui.Container(accent_colour=discord.Colour.blue())
|
|
if main_container is None:
|
|
raise AssertionError(
|
|
"ui.Container returned None in ListLevelRolesView; ensure accent_colour is valid"
|
|
)
|
|
self.add_item(main_container)
|
|
|
|
title_display = ui.TextDisplay(f"**Level Roles for {guild.name}**")
|
|
if title_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for title in ListLevelRolesView"
|
|
)
|
|
main_container.add_item(title_display)
|
|
|
|
sep = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if sep is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None in ListLevelRolesView"
|
|
)
|
|
main_container.add_item(sep)
|
|
|
|
if (
|
|
not level_roles_data
|
|
): # Should be caught by the check above, but good practice
|
|
empty_display = ui.TextDisplay(
|
|
"No level roles are registered for this server."
|
|
)
|
|
if empty_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for empty message in ListLevelRolesView"
|
|
)
|
|
main_container.add_item(empty_display)
|
|
return
|
|
|
|
sorted_roles_items = sorted(level_roles_data.items())
|
|
|
|
for level, role_data_or_id in sorted_roles_items:
|
|
role_section = ui.Section(
|
|
accessory=None
|
|
) # Explicitly pass accessory=None
|
|
if role_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None in ListLevelRolesView"
|
|
)
|
|
|
|
level_title = ui.TextDisplay(f"**Level {level}:**")
|
|
if level_title is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for level title in ListLevelRolesView"
|
|
)
|
|
role_section.add_item(level_title)
|
|
|
|
if isinstance(role_data_or_id, dict): # Gendered roles
|
|
for gender, role_id in role_data_or_id.items():
|
|
role = guild.get_role(role_id)
|
|
role_name = (
|
|
role.mention
|
|
if role
|
|
else f"Unknown Role (ID: {role_id})"
|
|
)
|
|
gender_display = ui.TextDisplay(
|
|
f" - {gender.capitalize()}: {role_name}"
|
|
)
|
|
if gender_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for gender role in ListLevelRolesView"
|
|
)
|
|
role_section.add_item(gender_display)
|
|
else: # Regular role
|
|
role = guild.get_role(role_data_or_id)
|
|
role_name = (
|
|
role.mention
|
|
if role
|
|
else f"Unknown Role (ID: {role_data_or_id})"
|
|
)
|
|
role_display = ui.TextDisplay(f" {role_name}")
|
|
if role_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for regular role in ListLevelRolesView"
|
|
)
|
|
role_section.add_item(role_display)
|
|
|
|
main_container.add_item(role_section)
|
|
if (
|
|
level != sorted_roles_items[-1][0]
|
|
): # Add separator if not the last item
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None between roles in ListLevelRolesView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
try:
|
|
view = ListLevelRolesView(ctx.guild, self.level_roles[ctx.guild.id])
|
|
await ctx.send(view=view)
|
|
except Exception as e:
|
|
print(f"Error creating list level roles view: {e}")
|
|
traceback.print_exc()
|
|
await ctx.send(
|
|
"❌ An error occurred while creating the level roles list. Please check the console for details."
|
|
)
|
|
|
|
@level.command(
|
|
name="restrict_channel", description="Restrict a channel from giving XP"
|
|
)
|
|
@commands.has_permissions(manage_channels=True)
|
|
async def restrict_channel(
|
|
self, ctx: commands.Context, channel: discord.TextChannel = None
|
|
):
|
|
"""Restrict a channel from giving XP"""
|
|
target_channel = channel or ctx.channel
|
|
|
|
if target_channel.id in self.restricted_channels:
|
|
await ctx.send(
|
|
f"{target_channel.mention} is already restricted from giving XP."
|
|
)
|
|
return
|
|
|
|
self.restricted_channels.add(target_channel.id)
|
|
self.save_restricted_channels()
|
|
await ctx.send(
|
|
f"✅ {target_channel.mention} will no longer give XP for messages."
|
|
)
|
|
|
|
@level.command(
|
|
name="unrestrict_channel", description="Allow a channel to give XP again"
|
|
)
|
|
@commands.has_permissions(manage_channels=True)
|
|
async def unrestrict_channel(
|
|
self, ctx: commands.Context, channel: discord.TextChannel = None
|
|
):
|
|
"""Allow a channel to give XP again"""
|
|
target_channel = channel or ctx.channel
|
|
|
|
if target_channel.id not in self.restricted_channels:
|
|
await ctx.send(
|
|
f"{target_channel.mention} is not restricted from giving XP."
|
|
)
|
|
return
|
|
|
|
self.restricted_channels.remove(target_channel.id)
|
|
self.save_restricted_channels()
|
|
await ctx.send(f"✅ {target_channel.mention} will now give XP for messages.")
|
|
|
|
@level.command(
|
|
name="process_messages", description="Process existing messages to award XP"
|
|
)
|
|
@commands.is_owner()
|
|
async def process_existing_messages(
|
|
self, ctx: commands.Context, limit: int = 10000
|
|
):
|
|
"""Process existing messages to award XP (Owner only)"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
status_message = await ctx.send(
|
|
f"Processing existing messages (up to {limit} per channel)..."
|
|
)
|
|
|
|
total_processed = 0
|
|
total_channels = 0
|
|
|
|
# Get all text channels in the guild
|
|
text_channels = [
|
|
channel
|
|
for channel in ctx.guild.channels
|
|
if isinstance(channel, discord.TextChannel)
|
|
]
|
|
|
|
for channel in text_channels:
|
|
# Skip restricted channels
|
|
if channel.id in self.restricted_channels:
|
|
continue
|
|
|
|
try:
|
|
processed_in_channel = 0
|
|
|
|
# Update status message
|
|
await status_message.edit(
|
|
content=f"Processing channel {channel.mention}... ({total_processed} messages processed so far)"
|
|
)
|
|
|
|
async for message in channel.history(limit=limit):
|
|
# Skip bot messages
|
|
if message.author.bot:
|
|
continue
|
|
|
|
# Add XP (without cooldown)
|
|
user_id = message.author.id
|
|
xp_amount = random.randint(10, 20)
|
|
await self.add_xp(user_id, ctx.guild.id, xp_amount)
|
|
|
|
processed_in_channel += 1
|
|
total_processed += 1
|
|
|
|
# Update status every 1000 messages
|
|
if total_processed % 1000 == 0:
|
|
await status_message.edit(
|
|
content=f"Processing channel {channel.mention}... ({total_processed} messages processed so far)"
|
|
)
|
|
|
|
total_channels += 1
|
|
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to read message history in {channel.mention}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error processing messages in {channel.mention}: {e}")
|
|
traceback.print_exc()
|
|
|
|
# Final update
|
|
await status_message.edit(
|
|
content=f"✅ Finished processing {total_processed} messages across {total_channels} channels."
|
|
)
|
|
|
|
@commands.Cog.listener()
|
|
async def on_raw_reaction_add(self, payload):
|
|
"""Event listener for reactions to award XP"""
|
|
# Check if reaction XP is enabled
|
|
if not self.config["reaction_xp_enabled"]:
|
|
return
|
|
|
|
# Ignore DM reactions (leveling is only for guilds)
|
|
if not payload.guild_id:
|
|
return
|
|
|
|
# Ignore bot reactions
|
|
if payload.member and payload.member.bot:
|
|
return
|
|
|
|
# Get the channel
|
|
channel = self.bot.get_channel(payload.channel_id)
|
|
if not channel:
|
|
return
|
|
|
|
# Ignore reactions in restricted channels
|
|
if channel.id in self.restricted_channels:
|
|
return
|
|
|
|
# Check cooldown
|
|
user_id = payload.user_id
|
|
current_time = discord.utils.utcnow().timestamp()
|
|
|
|
if user_id in self.reaction_cooldowns:
|
|
time_diff = current_time - self.reaction_cooldowns[user_id]
|
|
if time_diff < self.config["reaction_cooldown"]:
|
|
return # Still on cooldown
|
|
|
|
# Update cooldown
|
|
self.reaction_cooldowns[user_id] = current_time
|
|
|
|
# Add XP with small random variation (base ±2 XP)
|
|
base_xp = self.config["xp_per_reaction"]
|
|
xp_amount = random.randint(max(1, base_xp - 2), base_xp + 2)
|
|
new_level = await self.add_xp(user_id, payload.guild_id, xp_amount)
|
|
|
|
# If user leveled up, send a DM to avoid channel spam
|
|
if new_level:
|
|
try:
|
|
member = channel.guild.get_member(user_id)
|
|
if member:
|
|
await member.send(
|
|
f"🎉 Congratulations! You've reached level **{new_level}**!"
|
|
)
|
|
except discord.Forbidden:
|
|
pass # Ignore if we can't send DMs
|
|
|
|
@commands.Cog.listener()
|
|
async def on_ready(self):
|
|
print(f"{self.__class__.__name__} cog has been loaded.")
|
|
|
|
async def cog_unload(self):
|
|
"""Save all data when cog is unloaded"""
|
|
self.save_user_data()
|
|
self.save_level_roles()
|
|
self.save_restricted_channels()
|
|
self.save_config()
|
|
print(f"{self.__class__.__name__} cog has been unloaded and data saved.")
|
|
|
|
@level.command(name="config", description="Configure XP settings")
|
|
@commands.has_permissions(administrator=True)
|
|
async def xp_config(
|
|
self, ctx: commands.Context, setting: str = None, value: str = None
|
|
):
|
|
"""Configure XP settings for the leveling system"""
|
|
if not setting:
|
|
|
|
class XPConfigView(ui.LayoutView):
|
|
def __init__(self, config_data: dict, prefix: str):
|
|
super().__init__()
|
|
|
|
main_container = ui.Container(accent_colour=discord.Colour.blue())
|
|
if main_container is None:
|
|
raise AssertionError(
|
|
"ui.Container returned None in XPConfigView; ensure accent_colour is valid"
|
|
)
|
|
self.add_item(main_container)
|
|
|
|
title_text = ui.TextDisplay("**XP Configuration Settings**")
|
|
if title_text is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for title in XPConfigView"
|
|
)
|
|
main_container.add_item(title_text)
|
|
|
|
desc_text = ui.TextDisplay(
|
|
"Current XP settings for the leveling system:"
|
|
)
|
|
if desc_text is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for description in XPConfigView"
|
|
)
|
|
main_container.add_item(desc_text)
|
|
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None in XPConfigView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
settings_to_display = [
|
|
("XP Per Message", str(config_data["xp_per_message"])),
|
|
("XP Per Reaction", str(config_data["xp_per_reaction"])),
|
|
(
|
|
"Message Cooldown",
|
|
f"{config_data['message_cooldown']} seconds",
|
|
),
|
|
(
|
|
"Reaction Cooldown",
|
|
f"{config_data['reaction_cooldown']} seconds",
|
|
),
|
|
(
|
|
"Reaction XP Enabled",
|
|
"Yes" if config_data["reaction_xp_enabled"] else "No",
|
|
),
|
|
]
|
|
|
|
for name, value_str in settings_to_display:
|
|
setting_section = ui.Section(
|
|
accessory=None
|
|
) # Explicitly pass accessory=None
|
|
if setting_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None in XPConfigView"
|
|
)
|
|
|
|
setting_display = ui.TextDisplay(f"**{name}:** {value_str}")
|
|
if setting_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for setting in XPConfigView"
|
|
)
|
|
setting_section.add_item(setting_display)
|
|
main_container.add_item(setting_section)
|
|
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None at bottom in XPConfigView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
help_text = ui.TextDisplay(
|
|
f"Use {prefix}level config <setting> <value> to change a setting"
|
|
)
|
|
if help_text is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for help text in XPConfigView"
|
|
)
|
|
main_container.add_item(help_text)
|
|
|
|
# Attempt to get the prefix
|
|
try:
|
|
# This is a common way to get the prefix, but might need adjustment
|
|
# depending on how the bot is structured (e.g., if get_prefix is an async method or part of bot instance)
|
|
# For simplicity, assuming ctx.prefix exists or can be hardcoded if necessary.
|
|
# If ctx.prefix is not available, a default like "!" or the bot's mention could be used.
|
|
# Let's assume ctx.prefix is available for now.
|
|
# If not, we might need to ask the user or make an assumption.
|
|
# For now, let's try with ctx.prefix. If it causes an error, we can adjust.
|
|
# A safer bet might be to use the command's qualified name.
|
|
command_prefix = ctx.prefix if ctx.prefix else "!" # Fallback to "!"
|
|
except AttributeError:
|
|
command_prefix = "!" # Fallback if ctx.prefix doesn't exist
|
|
|
|
try:
|
|
view = XPConfigView(self.config, command_prefix)
|
|
await ctx.send(view=view)
|
|
except Exception as e:
|
|
print(f"Error creating XP config view: {e}")
|
|
traceback.print_exc()
|
|
await ctx.send(
|
|
"❌ An error occurred while creating the configuration display. Please check the console for details."
|
|
)
|
|
return
|
|
|
|
if not value:
|
|
await ctx.send("Please provide a value for the setting.")
|
|
return
|
|
|
|
setting = setting.lower()
|
|
|
|
if setting == "xp_per_message":
|
|
try:
|
|
xp = int(value)
|
|
if xp < 1 or xp > 100:
|
|
await ctx.send("XP per message must be between 1 and 100.")
|
|
return
|
|
self.config["xp_per_message"] = xp
|
|
await ctx.send(f"✅ XP per message set to {xp}.")
|
|
except ValueError:
|
|
await ctx.send("Value must be a number.")
|
|
|
|
elif setting == "xp_per_reaction":
|
|
try:
|
|
xp = int(value)
|
|
if xp < 1 or xp > 50:
|
|
await ctx.send("XP per reaction must be between 1 and 50.")
|
|
return
|
|
self.config["xp_per_reaction"] = xp
|
|
await ctx.send(f"✅ XP per reaction set to {xp}.")
|
|
except ValueError:
|
|
await ctx.send("Value must be a number.")
|
|
|
|
elif setting == "message_cooldown":
|
|
try:
|
|
cooldown = int(value)
|
|
if cooldown < 0 or cooldown > 3600:
|
|
await ctx.send(
|
|
"Message cooldown must be between 0 and 3600 seconds."
|
|
)
|
|
return
|
|
self.config["message_cooldown"] = cooldown
|
|
await ctx.send(f"✅ Message cooldown set to {cooldown} seconds.")
|
|
except ValueError:
|
|
await ctx.send("Value must be a number.")
|
|
|
|
elif setting == "reaction_cooldown":
|
|
try:
|
|
cooldown = int(value)
|
|
if cooldown < 0 or cooldown > 3600:
|
|
await ctx.send(
|
|
"Reaction cooldown must be between 0 and 3600 seconds."
|
|
)
|
|
return
|
|
self.config["reaction_cooldown"] = cooldown
|
|
await ctx.send(f"✅ Reaction cooldown set to {cooldown} seconds.")
|
|
except ValueError:
|
|
await ctx.send("Value must be a number.")
|
|
|
|
elif setting == "reaction_xp_enabled":
|
|
value = value.lower()
|
|
if value in ["true", "yes", "on", "1", "enable", "enabled"]:
|
|
self.config["reaction_xp_enabled"] = True
|
|
await ctx.send("✅ Reaction XP has been enabled.")
|
|
elif value in ["false", "no", "off", "0", "disable", "disabled"]:
|
|
self.config["reaction_xp_enabled"] = False
|
|
await ctx.send("✅ Reaction XP has been disabled.")
|
|
else:
|
|
await ctx.send("Value must be 'true' or 'false'.")
|
|
|
|
else:
|
|
await ctx.send(
|
|
f"Unknown setting: {setting}. Available settings: xp_per_message, xp_per_reaction, message_cooldown, reaction_cooldown, reaction_xp_enabled"
|
|
)
|
|
return
|
|
|
|
# Save the updated configuration
|
|
self.save_config()
|
|
|
|
@level.command(
|
|
name="toggle_notifs", description="Toggle level-up notifications for yourself"
|
|
)
|
|
async def toggle_level_notifs(self, ctx: commands.Context):
|
|
"""Toggle level-up notifications for yourself"""
|
|
user_data = self.get_user_data(ctx.author.id)
|
|
current_status = user_data.get(
|
|
"level_notifs_enabled", self.config["default_level_notifs_enabled"]
|
|
)
|
|
new_status = not current_status
|
|
user_data["level_notifs_enabled"] = new_status
|
|
self.save_user_data()
|
|
|
|
status_text = "enabled" if new_status else "disabled"
|
|
await ctx.send(
|
|
f"✅ Level-up notifications have been **{status_text}** for you."
|
|
)
|
|
|
|
@level.command(
|
|
name="setup_medieval_roles", description="Set up medieval-themed level roles"
|
|
)
|
|
@commands.has_permissions(manage_roles=True)
|
|
async def setup_medieval_roles(self, ctx: commands.Context):
|
|
"""Automatically set up medieval-themed level roles with gender customization"""
|
|
if not ctx.guild:
|
|
await ctx.send("This command can only be used in a server.")
|
|
return
|
|
|
|
# Define the medieval role structure with levels and titles
|
|
medieval_roles = {
|
|
1: {"default": "Peasant", "male": "Peasant", "female": "Peasant"},
|
|
5: {"default": "Squire", "male": "Squire", "female": "Squire"},
|
|
10: {"default": "Knight", "male": "Knight", "female": "Dame"},
|
|
20: {"default": "Baron/Baroness", "male": "Baron", "female": "Baroness"},
|
|
30: {"default": "Count/Countess", "male": "Count", "female": "Countess"},
|
|
50: {"default": "Duke/Duchess", "male": "Duke", "female": "Duchess"},
|
|
75: {"default": "Prince/Princess", "male": "Prince", "female": "Princess"},
|
|
100: {"default": "King/Queen", "male": "King", "female": "Queen"},
|
|
}
|
|
|
|
# Colors for the roles (gradient from gray to gold)
|
|
colors = {
|
|
1: discord.Color.from_rgb(128, 128, 128), # Gray
|
|
5: discord.Color.from_rgb(153, 153, 153), # Light Gray
|
|
10: discord.Color.from_rgb(170, 170, 170), # Silver
|
|
20: discord.Color.from_rgb(218, 165, 32), # Goldenrod
|
|
30: discord.Color.from_rgb(255, 215, 0), # Gold
|
|
50: discord.Color.from_rgb(255, 223, 0), # Bright Gold
|
|
75: discord.Color.from_rgb(255, 235, 0), # Royal Gold
|
|
100: discord.Color.from_rgb(255, 255, 0), # Yellow/Gold
|
|
}
|
|
|
|
# Initialize guild in level_roles if not exists
|
|
if ctx.guild.id not in self.level_roles:
|
|
self.level_roles[ctx.guild.id] = {}
|
|
|
|
status_message = await ctx.send("Creating medieval-themed level roles...")
|
|
created_roles = []
|
|
updated_roles = []
|
|
|
|
# Check if the server has pronoun roles
|
|
pronoun_roles = {}
|
|
for role in ctx.guild.roles:
|
|
role_name_lower = role.name.lower()
|
|
if "he/him" in role_name_lower:
|
|
pronoun_roles["male"] = role
|
|
elif "she/her" in role_name_lower:
|
|
pronoun_roles["female"] = role
|
|
|
|
has_pronoun_roles = len(pronoun_roles) > 0
|
|
|
|
# Create or update roles for each level
|
|
for level, titles in medieval_roles.items():
|
|
# For servers without pronoun roles, use the default title
|
|
if not has_pronoun_roles:
|
|
role_name = f"Level {level} - {titles['default']}"
|
|
|
|
# Check if role already exists
|
|
existing_role = discord.utils.get(ctx.guild.roles, name=role_name)
|
|
|
|
if existing_role:
|
|
# Update existing role
|
|
try:
|
|
await existing_role.edit(
|
|
color=colors[level], reason="Updating medieval level role"
|
|
)
|
|
updated_roles.append(role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(f"Missing permissions to edit role: {role_name}")
|
|
except Exception as e:
|
|
await ctx.send(f"Error updating role {role_name}: {e}")
|
|
traceback.print_exc()
|
|
else:
|
|
# Create new role
|
|
try:
|
|
role = await ctx.guild.create_role(
|
|
name=role_name,
|
|
color=colors[level],
|
|
reason="Creating medieval level role",
|
|
)
|
|
created_roles.append(role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to create role: {role_name}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error creating role {role_name}: {e}")
|
|
traceback.print_exc()
|
|
continue
|
|
|
|
# Register the role for this level
|
|
role_id = existing_role.id if existing_role else role.id
|
|
self.level_roles[ctx.guild.id][level] = role_id
|
|
|
|
# For servers with pronoun roles, create separate male and female roles
|
|
else:
|
|
# Create male role
|
|
male_role_name = f"Level {level} - {titles['male']}"
|
|
male_role = discord.utils.get(ctx.guild.roles, name=male_role_name)
|
|
|
|
if male_role:
|
|
try:
|
|
await male_role.edit(
|
|
color=colors[level], reason="Updating medieval level role"
|
|
)
|
|
updated_roles.append(male_role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to edit role: {male_role_name}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error updating role {male_role_name}: {e}")
|
|
traceback.print_exc()
|
|
else:
|
|
try:
|
|
male_role = await ctx.guild.create_role(
|
|
name=male_role_name,
|
|
color=colors[level],
|
|
reason="Creating medieval level role",
|
|
)
|
|
created_roles.append(male_role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to create role: {male_role_name}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error creating role {male_role_name}: {e}")
|
|
traceback.print_exc()
|
|
male_role = None
|
|
|
|
# Create female role
|
|
female_role_name = f"Level {level} - {titles['female']}"
|
|
female_role = discord.utils.get(ctx.guild.roles, name=female_role_name)
|
|
|
|
if female_role:
|
|
try:
|
|
await female_role.edit(
|
|
color=colors[level], reason="Updating medieval level role"
|
|
)
|
|
updated_roles.append(female_role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to edit role: {female_role_name}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error updating role {female_role_name}: {e}")
|
|
traceback.print_exc()
|
|
else:
|
|
try:
|
|
female_role = await ctx.guild.create_role(
|
|
name=female_role_name,
|
|
color=colors[level],
|
|
reason="Creating medieval level role",
|
|
)
|
|
created_roles.append(female_role_name)
|
|
except discord.Forbidden:
|
|
await ctx.send(
|
|
f"Missing permissions to create role: {female_role_name}"
|
|
)
|
|
except Exception as e:
|
|
await ctx.send(f"Error creating role {female_role_name}: {e}")
|
|
traceback.print_exc()
|
|
female_role = None
|
|
|
|
# Create a special entry for gendered roles
|
|
if level not in self.level_roles[ctx.guild.id]:
|
|
self.level_roles[ctx.guild.id][level] = {}
|
|
|
|
# Store the role IDs with gender information
|
|
if male_role:
|
|
self.level_roles[ctx.guild.id][level]["male"] = male_role.id
|
|
if female_role:
|
|
self.level_roles[ctx.guild.id][level]["female"] = female_role.id
|
|
|
|
# Save the updated level roles
|
|
self.save_level_roles()
|
|
|
|
class MedievalRolesSetupView(ui.LayoutView):
|
|
def __init__(
|
|
self,
|
|
created_roles_list: list,
|
|
updated_roles_list: list,
|
|
has_pronoun_roles_flag: bool,
|
|
):
|
|
super().__init__()
|
|
|
|
main_container = ui.Container(accent_colour=discord.Colour.gold())
|
|
if main_container is None:
|
|
raise AssertionError(
|
|
"ui.Container returned None in MedievalRolesSetupView; ensure accent_colour is valid"
|
|
)
|
|
self.add_item(main_container)
|
|
|
|
title_display = ui.TextDisplay("**Medieval Level Roles Setup**")
|
|
if title_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for title in MedievalRolesSetupView"
|
|
)
|
|
main_container.add_item(title_display)
|
|
|
|
desc_display = ui.TextDisplay(
|
|
"The following roles have been set up for the medieval leveling system:"
|
|
)
|
|
if desc_display is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for description in MedievalRolesSetupView"
|
|
)
|
|
main_container.add_item(desc_display)
|
|
|
|
sep = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if sep is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None in MedievalRolesSetupView"
|
|
)
|
|
main_container.add_item(sep)
|
|
|
|
if created_roles_list:
|
|
created_section = ui.Section(
|
|
accessory=None
|
|
) # Explicitly pass accessory=None
|
|
if created_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None for created roles in MedievalRolesSetupView"
|
|
)
|
|
|
|
created_title = ui.TextDisplay("**Created Roles:**")
|
|
if created_title is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for created roles title in MedievalRolesSetupView"
|
|
)
|
|
created_section.add_item(created_title)
|
|
|
|
# For potentially long lists, join with newline. TextDisplay handles multiline.
|
|
created_list = ui.TextDisplay(
|
|
"\n".join(created_roles_list) if created_roles_list else "None"
|
|
)
|
|
if created_list is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for created roles list in MedievalRolesSetupView"
|
|
)
|
|
created_section.add_item(created_list)
|
|
main_container.add_item(created_section)
|
|
|
|
if (
|
|
created_roles_list
|
|
): # Only add separator if there are created roles
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None after created roles in MedievalRolesSetupView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
if updated_roles_list:
|
|
updated_section = ui.Section(
|
|
accessory=None
|
|
) # Explicitly pass accessory=None
|
|
if updated_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None for updated roles in MedievalRolesSetupView"
|
|
)
|
|
|
|
updated_title = ui.TextDisplay("**Updated Roles:**")
|
|
if updated_title is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for updated roles title in MedievalRolesSetupView"
|
|
)
|
|
updated_section.add_item(updated_title)
|
|
|
|
updated_list = ui.TextDisplay(
|
|
"\n".join(updated_roles_list) if updated_roles_list else "None"
|
|
)
|
|
if updated_list is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for updated roles list in MedievalRolesSetupView"
|
|
)
|
|
updated_section.add_item(updated_list)
|
|
main_container.add_item(updated_section)
|
|
|
|
if (
|
|
updated_roles_list
|
|
): # Only add separator if there are updated roles
|
|
separator = ui.Separator(spacing=discord.SeparatorSpacing.small)
|
|
if separator is None:
|
|
raise AssertionError(
|
|
"ui.Separator returned None after updated roles in MedievalRolesSetupView"
|
|
)
|
|
main_container.add_item(separator)
|
|
|
|
gender_detection_section = ui.Section(
|
|
accessory=None
|
|
) # Explicitly pass accessory=None
|
|
if gender_detection_section is None:
|
|
raise AssertionError(
|
|
"ui.Section returned None for gender detection in MedievalRolesSetupView"
|
|
)
|
|
|
|
gender_title = ui.TextDisplay("**Gender Detection:**")
|
|
if gender_title is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for gender detection title in MedievalRolesSetupView"
|
|
)
|
|
gender_detection_section.add_item(gender_title)
|
|
|
|
gender_text = (
|
|
"Gender-specific roles will be assigned based on pronoun roles."
|
|
if has_pronoun_roles_flag
|
|
else "No pronoun roles detected. Using default titles."
|
|
)
|
|
gender_desc = ui.TextDisplay(gender_text)
|
|
if gender_desc is None:
|
|
raise AssertionError(
|
|
"ui.TextDisplay returned None for gender detection description in MedievalRolesSetupView"
|
|
)
|
|
gender_detection_section.add_item(gender_desc)
|
|
main_container.add_item(gender_detection_section)
|
|
|
|
try:
|
|
view = MedievalRolesSetupView(
|
|
created_roles, updated_roles, has_pronoun_roles
|
|
)
|
|
await status_message.edit(content=None, view=view)
|
|
except Exception as e:
|
|
print(f"Error creating medieval roles setup view: {e}")
|
|
traceback.print_exc()
|
|
await status_message.edit(
|
|
content="❌ An error occurred while creating the setup summary. Please check the console for details."
|
|
)
|
|
|
|
|
|
async def setup(bot: commands.Bot):
|
|
await bot.add_cog(LevelingCog(bot))
|