adb-plugin-levels 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# Levels & XP System
+
+A plugin for AdvancedDiscordBot that adds experience points, levels, and role rewards based on user activity.
+
+## Features
+
+- Track XP per user per guild
+- Award XP on message activity (with configurable rate limiting)
+- Level-up notifications
+- Role rewards for reaching specific levels
+- Leaderboard commands
+- Admin configuration
+
+## Commands
+
+- `/level` - Check your or another user's level and XP
+- `/leaderboard` - View the server XP ranking (top 10)
+- `/level-config` - Admin: Configure XP rates, cooldowns, and level-up channel
+- `/level-roles` - Admin: Manage role rewards for specific levels
+
+## Installation
+
+1. Copy this folder to your bot's `plugins/` directory
+2. Restart the bot (required for slash command registration)
+3. Use `/level-config` to set up the plugin
+
+## Configuration
+
+- `xpPerMessage`: Amount of XP awarded per message (default: 5)
+- `xpCooldown`: Seconds between XP awards for the same user (default: 60)
+- `xpPerMinuteLimit`: Maximum XP a user can earn per minute (default: 100)
+- `levelUpChannelId`: Channel ID for level-up announcements (optional)
+
+## How It Works
+
+XP is awarded based on message activity with anti-spam protection. Levels are calculated using the formula: `level = floor(sqrt(xp / 100))`.
+
+When a user levels up:
+- Their level is updated in the database
+- A level-up event is emitted for other plugins to listen to
+- A message is sent in the configured level-up channel (if set)
+- Any role rewards for the new level are automatically assigned
+
+## Database Models
+
+The plugin creates three namespaced collections:
+- `plugin_adb-plugin-levels_level` - Stores user XP and levels
+- `plugin_adb-plugin-levels_levelconfig` - Stores guild configuration
+- `plugin_adb-plugin-levels_leaderole` - Stores level-to-role mappings
+
+## Dependencies
+
+- discord.js ^14.14.1
+- mongoose ^8.0.3
+
+## License
+
+MIT

package/commands/leaderboard.js

@@ -0,0 +1,48 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+
+const data = new SlashCommandBuilder()
+  .setName('leaderboard')
+  .setDescription('View the server XP leaderboard');
+
+async function execute(interaction) {
+  try {
+    const guildId = interaction.guild.id;
+    const Level = require('../../models/Level');
+    
+    const leaderboard = await Level.find({ guildId })
+      .sort({ xp: -1 })
+      .limit(10)
+      .populate('userId', 'username discriminator avatar');
+    
+    if (leaderboard.length === 0) {
+      await interaction.reply({ 
+        content: 'No one has earned XP yet!', 
+        ephemeral: true 
+      });
+      return;
+    }
+    
+    const embed = new EmbedBuilder()
+      .setTitle(`${interaction.guild.name} Leaderboard`)
+      .setColor(0xffd700);
+    
+    const description = leaderboard.map((entry, index) => {
+      const medal = ['🥇', '🥈', '🥉'][index] || `${index + 1}.`;
+      const xp = (entry.xp || 0).toLocaleString();
+      const level = Math.floor(Math.sqrt((entry.xp || 0) / 100));
+      const username = interaction.guild.members.cache.get(entry.userId)?.user.username || 'Unknown User';
+      return `${medal} **${username}** - Level ${level} • ${xp} XP`;
+    }).join('\n');
+    
+    embed.setDescription(description);
+    await interaction.reply({ embeds: [embed] });
+  } catch (error) {
+    console.error(error);
+    await interaction.reply({ 
+      content: 'There was an error while fetching the leaderboard!', 
+      ephemeral: true 
+    });
+  }
+}
+
+module.exports = { data, execute };

package/commands/level-config.js

@@ -0,0 +1,80 @@
+const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require('discord.js');
+
+const data = new SlashCommandBuilder()
+  .setName('level-config')
+  .setDescription('Configure the levels/XP system')
+  .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
+  .addIntegerOption(option =>
+    option.setName('xp-per-message')
+      .setDescription('XP awarded per message (1-50)')
+      .setMinValue(1)
+      .setMaxValue(50))
+  .addIntegerOption(option =>
+    option.setName('xp-cooldown')
+      .setDescription('Seconds between XP awards (10-300)')
+      .setMinValue(10)
+      .setMaxValue(300))
+  .addIntegerOption(option =>
+    option.setName('xp-per-minute-limit')
+      .setDescription('Max XP per minute (10-1000)')
+      .setMinValue(10)
+      .setMaxValue(1000))
+  .addChannelOption(option =>
+    option.setName('level-up-channel')
+      .setDescription('Channel for level-up announcements')
+      .addChannelTypes(0)); // GUILD_TEXT
+
+async function execute(interaction) {
+  try {
+    const guildId = interaction.guild.id;
+    const updates = {};
+    
+    if (interaction.options.getInteger('xp-per-message') !== null) {
+      updates.xpPerMessage = interaction.options.getInteger('xp-per-message');
+    }
+    if (interaction.options.getInteger('xp-cooldown') !== null) {
+      updates.xpCooldown = interaction.options.getInteger('xp-cooldown');
+    }
+    if (interaction.options.getInteger('xp-per-minute-limit') !== null) {
+      updates.xpPerMinuteLimit = interaction.options.getInteger('xp-per-minute-limit');
+    }
+    if (interaction.options.getChannel('level-up-channel') !== null) {
+      updates.levelUpChannelId = interaction.options.getChannel('level-up-channel').id;
+    }
+    
+    // Update guild config
+    const config = await ctx.db.getServerConfig(guildId) || {};
+    if (!config.xpPerModule) config.xpPerModule = {};
+    config.xpPerModule.levels = { ...config.xpPerModule.levels || {}, ...updates };
+    await ctx.db.updateServerConfig(guildId, config);
+    
+    const embed = new EmbedBuilder()
+      .setTitle('Levels Configuration Updated')
+      .setColor(0x00ff00)
+      .setDescription('The levels/XP system settings have been updated.');
+    
+    if (updates.xpPerMessage !== undefined) {
+      embed.addFields({ name: 'XP per Message', value: `${updates.xpPerMessage}` });
+    }
+    if (updates.xpCooldown !== undefined) {
+      addFields({ name: 'XP Cooldown', value: `${updates.xpCooldown}s` });
+    }
+    if (updates.xpPerMinuteLimit !== undefined) {
+      embed.addFields({ name: 'XP per Minute Limit', value: `${updates.xpPerMinuteLimit}` });
+    }
+    if (updates.levelUpChannelId !== undefined) {
+      const channel = interaction.guild.channels.cache.get(updates.levelUpChannelId);
+      embed.addFields({ name: 'Level-Up Channel', value: `${channel}` });
+    }
+    
+    await interaction.reply({ embeds: [embed] });
+  } catch (error) {
+    console.error(error);
+    await interaction.reply({ 
+      content: 'There was an error while updating the configuration!', 
+      ephemeral: true 
+    });
+  }
+}
+
+module.exports = { data, execute };

package/commands/level-roles.js

@@ -0,0 +1,98 @@
+const { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } = require('discord.js');
+
+const data = new SlashCommandBuilder()
+  .setName('level-roles')
+  .setDescription('Manage role rewards for levels')
+  .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
+  .addSubcommand(subcommand =>
+    subcommand
+      .setName('add')
+      .setDescription('Add a role reward for a level')
+      .addIntegerOption(option =>
+        option.setName('level')
+          .setDescription('The level required')
+          .setMinValue(1)
+          .setRequired(true))
+      .addRoleOption(option =>
+        option.setName('role')
+          .setDescription('The role to reward')
+          .setRequired(true)))
+  .addSubcommand(subcommand =>
+    subcommand
+      .setName('remove')
+      .setDescription('Remove a role reward for a level')
+      .addIntegerOption(option =>
+        option.setName('level')
+          .setDescription('The level to remove')
+          .setMinValue(1)
+          .setRequired(true)))
+  .addSubcommand(subcommand =>
+    subcommand
+      .setName('list')
+      .setDescription('List all role rewards for this server'));
+
+async function execute(interaction) {
+  try {
+    const guildId = interaction.guild.id;
+    const LevelRole = require('../../models/LevelRole');
+    
+    const subcommand = interaction.options.getSubcommand();
+    
+    if (subcommand === 'add') {
+      const level = interaction.options.getInteger('level');
+      const role = interaction.options.getRole('role');
+      
+      await LevelRole.findOneAndUpdate(
+        { guildId, level },
+        { $set: { roleId: role.id } },
+        { upsert: true, new: true }
+      );
+      
+      await interaction.reply({ 
+        content: `Successfully set ${role} as reward for reaching level ${level}!`, 
+        ephemeral: true 
+      });
+    } 
+    else if (subcommand === 'remove') {
+      const level = interaction.options.getInteger('level');
+      
+      await LevelRole.deleteOne({ guildId, level });
+      
+      await interaction.reply({ 
+        content: `Successfully removed role reward for level ${level}!`, 
+        ephemeral: true 
+      });
+    }
+    else if (subcommand === 'list') {
+      const roles = await LevelRole.find({ guildId }).sort({ level: 1 });
+      
+      if (roles.length === 0) {
+        await interaction.reply({ 
+          content: 'No role rewards configured for this server.', 
+          ephemeral: true 
+        });
+        return;
+      }
+      
+      const embed = new EmbedBuilder()
+        .setTitle('Level Role Rewards')
+        .setColor(0x9b59b6);
+      
+      const description = roles.map(r => {
+        const role = interaction.guild.roles.cache.get(r.roleId);
+        return `**Level ${r.level}** → ${role ? role : '@deleted-role'}`;
+      }).join('\n');
+      
+      embed.setDescription(description);
+      await interaction.reply({ embeds: [embed] });
+    }
+  } catch (error) {
+    console.error(error);
+    await interaction.reply({ 
+      content: 'There was an error while managing level roles!', 
+      ephemeral: true 
+    });
+  }
+}
+
+module.exports = { data, execute };

package/commands/level.js

@@ -0,0 +1,57 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+
+const data = new SlashCommandBuilder()
+  .setName('level')
+  .setDescription('Check your or another user\'s level and XP')
+  .addUserOption(option =>
+    option.setName('user')
+      .setDescription('The user to check')
+      .setRequired(false));
+
+async function execute(interaction) {
+  try {
+    const targetUser = interaction.options.getUser('user') || interaction.user;
+    const guildId = interaction.guild.id;
+    const userId = targetUser.id;
+    
+    const Level = require('../../models/Level');
+    const levelData = await Level.findOne({ guildId, userId });
+    
+    if (!levelData) {
+      await interaction.reply({ 
+        content: `${targetUser} has not earned any XP yet.`, 
+        ephemeral: true 
+      });
+      return;
+    }
+    
+    // Simple level formula: level = floor(sqrt(xp / 100))
+    const xp = levelData.xp || 0;
+    const level = Math.floor(Math.sqrt(xp / 100));
+    const xpForCurrentLevel = level * level * 100;
+    const xpForNextLevel = (level + 1) * (level + 1) * 100;
+    const xpNeeded = xpForNextLevel - xp;
+    const progressPercent = ((xp - xpForCurrentLevel) / (xpForNextLevel - xpForCurrentLevel)) * 100;
+    
+    const embed = new EmbedBuilder()
+      .setTitle(`${targetUser.username}'s Level`)
+      .setThumbnail(targetUser.displayAvatarURL())
+      .addFields(
+        { name: 'Level', value: `${level}`, inline: true },
+        { name: 'XP', value: `${xp.toLocaleString()} / ${xpForNextLevel.toLocaleString()}`, inline: true },
+        { name: 'Progress', value: `${progressPercent.toFixed(1)}%`, inline: true }
+      )
+      .setColor(0x0099ff)
+      .setTimestamp();
+    
+    await interaction.reply({ embeds: [embed] });
+  } catch (error) {
+    console.error(error);
+    await interaction.reply({ 
+      content: 'There was an error while fetching the level!', 
+      ephemeral: true 
+    });
+  }
+}
+
+module.exports = { data, execute };

package/index.js

@@ -0,0 +1,106 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+async function load(ctx) {
+  ctx.logger.info('Levels plugin loading...');
+  
+  // Register commands
+  const levelCmd = require('./commands/level');
+  const leaderboardCmd = require('./commands/leaderboard');
+  const levelConfigCmd = require('./commands/level-config');
+  const levelRolesCmd = require('./commands/level-roles');
+  
+  ctx.registerCommand(levelCmd);
+  ctx.registerCommand(leaderboardCmd);
+  ctx.registerCommand(levelConfigCmd);
+  ctx.registerCommand(levelRolesCmd);
+  
+  // Define models
+  const LevelSchema = require('./models/Level');
+  const LevelConfigSchema = require('./models/LevelConfig');
+  const LevelRoleSchema = require('./models/LevelRole');
+  
+  const LevelModel = ctx.defineModel('Level', LevelSchema);
+  const LevelConfigModel = ctx.defineModel('LevelConfig', LevelConfigSchema);
+  const LevelRoleModel = ctx.defineModel('LevelRole', LevelRoleSchema);
+  
+  // Listen for message events to award XP
+  ctx.client.on('messageCreate', async (message) => {
+    if (message.author.bot || !message.guild) return;
+    
+    try {
+      // Get guild config
+      const config = await ctx.db.getServerConfig(message.guild.id) || {};
+      const xpPerMessage = config.xpPerModule?.levels?.xpPerMessage ?? 5;
+      const xpCooldown = config.xpPerModule?.levels?.xpCooldown ?? 60;
+      const xpPerMinuteLimit = config.xpPerModule?.levels?.xpPerMinuteLimit ?? 100;
+      
+      // Simple rate limiting (in production use Redis or similar)
+      const now = Date.now();
+      const key = `xp_${message.guild.id}_${message.author.id}`;
+      
+      // For simplicity, we'll just award XP with basic cooldown per user
+      // A real implementation would use a proper rate limiter
+      const lastXp = await ctx.db.get(`xp:${key}`) || 0;
+      if (now - lastXp < xpCooldown * 1000) return;
+      
+      // Award XP
+      const levelData = await LevelModel.findOneAndUpdate(
+        { guildId: message.guild.id, userId: message.author.id },
+        { $inc: { xp: xpPerMessage }, $set: { lastMessageAt: new Date() } },
+        { upsert: true, new: true }
+      );
+      
+      // Check for level up
+      const oldLevel = Math.floor(Math.sqrt(levelData.xp / 100)); // Simple level formula
+      const newLevel = Math.floor(Math.sqrt((levelData.xp + xpPerMessage) / 100));
+      
+      if (newLevel > oldLevel) {
+        // Level up!
+        await LevelModel.updateOne(
+          { guildId: message.guild.id, userId: message.author.id },
+          { $set: { level: newLevel } }
+        );
+        
+        // Emit level up event for other plugins
+        ctx.hooks.emitHook('onLevelUp', { 
+          user: message.author, 
+          newLevel: newLevel, 
+          guild: message.guild 
+        });
+        
+        // Send level up message if channel configured
+        const levelUpChannelId = config.xpPerModule?.levels?.levelUpChannelId;
+        if (levelUpChannelId) {
+          const channel = message.guild.channels.cache.get(levelUpChannelId);
+          if (channel) {
+            channel.send(`${message.author} has reached level ${newLevel}! :tada:`);
+          }
+        }
+        
+        // Check for role rewards
+        const roleRewards = await LevelRoleModel.find({ guildId: message.guild.id, level: newLevel });
+        for (const reward of roleRewards) {
+          const role = message.guild.roles.cache.get(reward.roleId);
+          if (role && !message.member.roles.cache.has(role.id)) {
+            await message.member.roles.add(role);
+            try {
+              await message.author.send(`You earned the ${role.name} role for reaching level ${newLevel}!`);
+            } catch (e) {
+              // DMs closed
+            }
+          }
+        }
+      }
+      
+      // Update XP timestamp
+      await ctx.db.set(`xp:${key}`, now);
+      
+    } catch (error) {
+      ctx.logger.error('Error in levels plugin:', error);
+    }
+  });
+  
+  ctx.logger.info('Levels plugin loaded!');
+}
+
+module.exports = { load };

package/models/Level.js

@@ -0,0 +1,17 @@
+const { Schema, model } = require('mongoose');
+
+const LevelSchema = new Schema({
+  guildId: { type: String, required: true, index: true },
+  userId: { type: String, required: true, index: true },
+  xp: { type: Number, default: 0 },
+  level: { type: Number, default: 0 },
+  lastMessageAt: { type: Date, default: Date.now }
+}, {
+  collection: 'plugin_adb-plugin-levels_level',
+  timestamps: true
+});
+
+// Compound index for efficient queries
+LevelSchema.index({ guildId: 1, userId: 1 }, { unique: true });
+
+module.exports = LevelSchema;

package/models/LevelConfig.js

@@ -0,0 +1,14 @@
+const { Schema, model } = require('mongoose');
+
+const LevelConfigSchema = new Schema({
+  guildId: { type: String, required: true, unique: true },
+  xpPerMessage: { type: Number, default: 5 },
+  xpCooldown: { type: Number, default: 60 },
+  xpPerMinuteLimit: { type: Number, default: 100 },
+  levelUpChannelId: { type: String, default: null }
+}, {
+  collection: 'plugin_adb-plugin-levels_levelconfig',
+  timestamps: true
+});
+
+module.exports = LevelConfigSchema;

package/models/LevelRole.js

@@ -0,0 +1,15 @@
+const { Schema, model } = require('mongoose');
+
+const LevelRoleSchema = new Schema({
+  guildId: { type: String, required: true, index: true },
+  level: { type: Number, required: true, min: 1 },
+  roleId: { type: String, required: true }
+}, {
+  collection: 'plugin_adb-plugin-levels_leaderole',
+  timestamps: true
+});
+
+// Compound index for efficient queries
+LevelRoleSchema.index({ guildId: 1, level: 1 }, { unique: true });
+
+module.exports = LevelRoleSchema;

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "adb-plugin-levels",
+  "version": "1.0.0",
+  "description": "Levels & XP System plugin for AdvancedDiscordBot",
+  "main": "index.js",
+  "dependencies": {
+    "discord.js": "^14.14.1",
+    "mongoose": "^8.0.3"
+  }
+}

package/plugin.json

@@ -0,0 +1,42 @@
+{
+  "name": "adb-plugin-levels",
+  "displayName": "Levels & XP System",
+  "version": "1.0.0",
+  "description": "Track user activity with XP, levels, and role rewards",
+  "author": "dead",
+  "main": "index.js",
+  "requiresRestart": false,
+  "permissions": [
+    "db.read",
+    "db.write",
+    "commands.register",
+    "events.register"
+  ],
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "xpPerMessage": {
+        "type": "number",
+        "default": 5,
+        "minimum": 1,
+        "maximum": 50
+      },
+      "xpCooldown": {
+        "type": "number",
+        "default": 60,
+        "minimum": 10,
+        "maximum": 300
+      },
+      "xpPerMinuteLimit": {
+        "type": "number",
+        "default": 100,
+        "minimum": 10,
+        "maximum": 1000
+      },
+      "levelUpChannelId": {
+        "type": "string",
+        "default": null
+      }
+    }
+  }
+}