mirror of
https://github.com/arthur-pbty/LazyBot.git
synced 2026-06-03 15:07:29 +02:00
Arthur Puechberty
567 lines
18 KiB
JavaScript
567 lines
18 KiB
JavaScript
const db = require("./db");
|
|
|
|
const { Client, GatewayIntentBits, Events, Partials } = require("discord.js");
|
|
|
|
const client = new Client({
|
|
intents: Object.values(GatewayIntentBits),
|
|
partials: [
|
|
Partials.Message,
|
|
Partials.Channel,
|
|
Partials.GuildMember,
|
|
Partials.User
|
|
]
|
|
});
|
|
|
|
require("./loader/events.js")(client);
|
|
require("./loader/commands.js")(client);
|
|
|
|
|
|
setInterval(() => {
|
|
// vérification des membres vocaux pour leur faire gagner de l'xp
|
|
client.guilds.cache.forEach(guild => {
|
|
guild.members.cache.forEach(member => {
|
|
if (member.user.bot) return;
|
|
|
|
const voiceState = member.voice;
|
|
if (!voiceState.channelId) return;
|
|
|
|
const guildId = guild.id;
|
|
|
|
db.get(
|
|
`SELECT
|
|
enabled,
|
|
level_announcements_enabled,
|
|
level_announcements_channel_id,
|
|
level_announcements_message,
|
|
xp_courbe_type,
|
|
multiplier_courbe_for_level,
|
|
level_annoncement_every_level,
|
|
level_max,
|
|
role_with_without_type,
|
|
role_with_without_xp,
|
|
salon_with_without_type,
|
|
salon_with_without_xp,
|
|
gain_xp_on_voice,
|
|
gain_voice_xp_lower_bound,
|
|
gain_voice_xp_upper_bound
|
|
FROM levels_config WHERE guild_id = ?`,
|
|
[guildId],
|
|
(err, row) => {
|
|
if (err || !row || !row.enabled || !row.gain_xp_on_voice) return;
|
|
if (row.role_with_without_type === "with") {
|
|
const userRoles = member.roles.cache;
|
|
const requiredRoles = JSON.parse(row.role_with_without_xp || "[]");
|
|
if (!requiredRoles.some(roleId => userRoles.has(roleId))) {
|
|
return; // User has an excluded role
|
|
}
|
|
} else if (row.role_with_without_type === "without") {
|
|
const userRoles = member.roles.cache;
|
|
const excludedRoles = JSON.parse(row.role_with_without_xp || "[]");
|
|
if (excludedRoles.some(roleId => userRoles.has(roleId))) {
|
|
return; // User does not have any of the required roles
|
|
}
|
|
} else if (row.salon_with_without_type === "with") {
|
|
const channelId = voiceState.channelId;
|
|
const requiredChannels = JSON.parse(row.salon_with_without_xp || "[]");
|
|
if (!requiredChannels.includes(channelId)) {
|
|
return; // Not in a required channel
|
|
}
|
|
} else if (row.salon_with_without_type === "without") {
|
|
const channelId = voiceState.channelId;
|
|
const excludedChannels = JSON.parse(row.salon_with_without_xp || "[]");
|
|
if (excludedChannels.includes(channelId)) {
|
|
return; // In an excluded channel
|
|
}
|
|
}
|
|
|
|
const minXp = row.gain_voice_xp_lower_bound;
|
|
const maxXp = row.gain_voice_xp_upper_bound;
|
|
const xpToAdd = Math.floor(Math.random() * (maxXp - minXp + 1)) + minXp;
|
|
|
|
db.get(
|
|
`SELECT xp, level FROM user_levels WHERE guild_id = ? AND user_id = ?`,
|
|
[guildId, member.id],
|
|
(err, userRow) => {
|
|
if (err) return;
|
|
|
|
let newXp;
|
|
let newLevel;
|
|
|
|
if (userRow) {
|
|
newXp = userRow.xp + xpToAdd;
|
|
newLevel = userRow.level;
|
|
} else {
|
|
newXp = xpToAdd;
|
|
newLevel = 1;
|
|
}
|
|
|
|
// Level up logic
|
|
const multiplier = row.multiplier_courbe_for_level;
|
|
let fonction_courbe;
|
|
|
|
if (row.xp_courbe_type === "constante") {
|
|
fonction_courbe = (level) => multiplier;
|
|
} else if (row.xp_courbe_type === "linear") {
|
|
fonction_courbe = (level) => (level) * multiplier;
|
|
} else if (row.xp_courbe_type === "quadratic") {
|
|
fonction_courbe = (level) => (level) * (level) * multiplier;
|
|
} else if (row.xp_courbe_type === "exponential") {
|
|
fonction_courbe = (level) => Math.pow(2, (level - 1)) * multiplier;
|
|
}
|
|
|
|
let xpForNextLevel = fonction_courbe(newLevel);
|
|
while (newXp >= xpForNextLevel && (row.level_max === 0 || newLevel < row.level_max)) {
|
|
newXp -= xpForNextLevel;
|
|
newLevel += 1;
|
|
xpForNextLevel = fonction_courbe(newLevel);
|
|
|
|
// Announce level up if enabled and meets the criteria
|
|
if (row.level_announcements_enabled && (newLevel % row.level_annoncement_every_level === 0)) {
|
|
const channel = guild.channels.cache.get(row.level_announcements_channel_id);
|
|
console.log("Channel for level announcement:", channel);
|
|
if (channel) {
|
|
let announcementMsg = row.level_announcements_message;
|
|
announcementMsg = announcementMsg
|
|
.replace("{user}", member.user.username)
|
|
.replace("{mention}", `<@${member.id}>`)
|
|
.replace("{level}", newLevel)
|
|
.replace("{level-xp}", xpForNextLevel);
|
|
channel.send(announcementMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
db.run(
|
|
`INSERT INTO user_levels (guild_id, user_id, xp, level)
|
|
VALUES (?, ?, ?, ?)
|
|
ON CONFLICT(guild_id, user_id) DO UPDATE SET
|
|
xp = excluded.xp,
|
|
level = excluded.level`,
|
|
[guildId, member.id, newXp, newLevel]
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
});
|
|
});
|
|
}, 60 * 1000); // Toutes les minutes
|
|
|
|
|
|
// ===== STATS CHANNELS UPDATE =====
|
|
// Met à jour les noms des salons de statistiques toutes les 5 minutes
|
|
async function updateStatsChannels() {
|
|
try {
|
|
const statsChannels = await db.allAsync(`SELECT * FROM stats_channels`);
|
|
|
|
for (const config of statsChannels) {
|
|
const guild = client.guilds.cache.get(config.guild_id);
|
|
if (!guild) continue;
|
|
|
|
const channel = guild.channels.cache.get(config.channel_id);
|
|
if (!channel) continue;
|
|
|
|
let statValue;
|
|
|
|
switch (config.stat_type) {
|
|
case "members":
|
|
// Total des membres
|
|
statValue = guild.memberCount;
|
|
break;
|
|
|
|
case "humans":
|
|
// Membres sans les bots
|
|
await guild.members.fetch();
|
|
statValue = guild.members.cache.filter(m => !m.user.bot).size;
|
|
break;
|
|
|
|
case "bots":
|
|
// Nombre de bots
|
|
await guild.members.fetch();
|
|
statValue = guild.members.cache.filter(m => m.user.bot).size;
|
|
break;
|
|
|
|
case "online":
|
|
// Membres en ligne (online, idle, dnd)
|
|
await guild.members.fetch({ withPresences: true });
|
|
statValue = guild.members.cache.filter(m =>
|
|
m.presence && ["online", "idle", "dnd"].includes(m.presence.status)
|
|
).size;
|
|
break;
|
|
|
|
case "voice":
|
|
// Membres en vocal
|
|
statValue = guild.members.cache.filter(m => m.voice.channelId).size;
|
|
break;
|
|
|
|
case "roles":
|
|
// Nombre de rôles
|
|
statValue = guild.roles.cache.size;
|
|
break;
|
|
|
|
case "channels":
|
|
// Nombre de salons
|
|
statValue = guild.channels.cache.size;
|
|
break;
|
|
|
|
case "boosts":
|
|
// Nombre de boosts
|
|
statValue = guild.premiumSubscriptionCount || 0;
|
|
break;
|
|
|
|
case "boost_level":
|
|
// Niveau de boost
|
|
statValue = guild.premiumTier;
|
|
break;
|
|
|
|
case "role_members":
|
|
// Membres ayant un rôle spécifique
|
|
if (config.role_id) {
|
|
await guild.members.fetch();
|
|
const role = guild.roles.cache.get(config.role_id);
|
|
statValue = role ? role.members.size : 0;
|
|
} else {
|
|
statValue = 0;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
statValue = "?";
|
|
}
|
|
|
|
// Construire le nouveau nom
|
|
const newName = config.format.replace("{stat}", statValue);
|
|
|
|
// Ne mettre à jour que si le nom a changé
|
|
if (channel.name !== newName) {
|
|
try {
|
|
await channel.setName(newName);
|
|
} catch (err) {
|
|
console.error(`Erreur lors de la mise à jour du salon ${config.channel_id}:`, err.message);
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error("Erreur updateStatsChannels:", err);
|
|
}
|
|
}
|
|
|
|
// Met à jour uniquement les stats d'un type spécifique pour un serveur
|
|
async function updateGuildStats(guildId, statTypes) {
|
|
try {
|
|
const statsChannels = await db.allAsync(
|
|
`SELECT * FROM stats_channels WHERE guild_id = ? AND stat_type IN (${statTypes.map(() => '?').join(',')})`,
|
|
[guildId, ...statTypes]
|
|
);
|
|
|
|
const guild = client.guilds.cache.get(guildId);
|
|
if (!guild) return;
|
|
|
|
for (const config of statsChannels) {
|
|
const channel = guild.channels.cache.get(config.channel_id);
|
|
if (!channel) continue;
|
|
|
|
let statValue;
|
|
|
|
switch (config.stat_type) {
|
|
case "members":
|
|
statValue = guild.memberCount;
|
|
break;
|
|
case "humans":
|
|
statValue = guild.members.cache.filter(m => !m.user.bot).size;
|
|
break;
|
|
case "bots":
|
|
statValue = guild.members.cache.filter(m => m.user.bot).size;
|
|
break;
|
|
case "online":
|
|
statValue = guild.members.cache.filter(m =>
|
|
m.presence && ["online", "idle", "dnd"].includes(m.presence.status)
|
|
).size;
|
|
break;
|
|
case "voice":
|
|
statValue = guild.members.cache.filter(m => m.voice.channelId).size;
|
|
break;
|
|
case "roles":
|
|
statValue = guild.roles.cache.size;
|
|
break;
|
|
case "channels":
|
|
statValue = guild.channels.cache.size;
|
|
break;
|
|
case "boosts":
|
|
statValue = guild.premiumSubscriptionCount || 0;
|
|
break;
|
|
case "boost_level":
|
|
statValue = guild.premiumTier;
|
|
break;
|
|
case "role_members":
|
|
if (config.role_id) {
|
|
const role = guild.roles.cache.get(config.role_id);
|
|
statValue = role ? role.members.size : 0;
|
|
} else {
|
|
statValue = 0;
|
|
}
|
|
break;
|
|
default:
|
|
statValue = "?";
|
|
}
|
|
|
|
const newName = config.format.replace("{stat}", statValue);
|
|
|
|
if (channel.name !== newName) {
|
|
try {
|
|
await channel.setName(newName);
|
|
} catch (err) {
|
|
console.error(`Erreur mise à jour salon ${config.channel_id}:`, err.message);
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error("Erreur updateGuildStats:", err);
|
|
}
|
|
}
|
|
|
|
// Debounce pour éviter le rate limiting (Discord limite le renommage de salon à 2 fois par 10 minutes)
|
|
const statsDebounceTimers = new Map();
|
|
function debounceStatsUpdate(guildId, statTypes, delay = 10000) {
|
|
const key = `${guildId}-${statTypes.sort().join(",")}`;
|
|
|
|
if (statsDebounceTimers.has(key)) {
|
|
clearTimeout(statsDebounceTimers.get(key));
|
|
}
|
|
|
|
statsDebounceTimers.set(key, setTimeout(() => {
|
|
updateGuildStats(guildId, statTypes);
|
|
statsDebounceTimers.delete(key);
|
|
}, delay));
|
|
}
|
|
|
|
// ===== ÉVÉNEMENTS POUR LES STATS =====
|
|
|
|
// Membre rejoint/quitte -> members, humans, bots
|
|
client.on("guildMemberAdd", (member) => {
|
|
const types = ["members", "humans"];
|
|
if (member.user.bot) types.push("bots");
|
|
debounceStatsUpdate(member.guild.id, types);
|
|
});
|
|
|
|
client.on("guildMemberRemove", (member) => {
|
|
const types = ["members", "humans"];
|
|
if (member.user.bot) types.push("bots");
|
|
debounceStatsUpdate(member.guild.id, types);
|
|
});
|
|
|
|
// Changement de présence -> online
|
|
client.on("presenceUpdate", (oldPresence, newPresence) => {
|
|
if (!newPresence || !newPresence.guild) return;
|
|
const wasOnline = oldPresence && ["online", "idle", "dnd"].includes(oldPresence.status);
|
|
const isOnline = ["online", "idle", "dnd"].includes(newPresence.status);
|
|
if (wasOnline !== isOnline) {
|
|
debounceStatsUpdate(newPresence.guild.id, ["online"]);
|
|
}
|
|
});
|
|
|
|
// Changement vocal -> voice (géré dans voiceStateUpdate.js mais on ajoute ici pour les stats)
|
|
client.on("voiceStateUpdate", (oldState, newState) => {
|
|
const guildId = newState.guild?.id || oldState.guild?.id;
|
|
if (!guildId) return;
|
|
// Si rejoint ou quitte un vocal
|
|
if (oldState.channelId !== newState.channelId) {
|
|
debounceStatsUpdate(guildId, ["voice"]);
|
|
}
|
|
});
|
|
|
|
// Rôle créé/supprimé -> roles
|
|
client.on("roleCreate", (role) => {
|
|
debounceStatsUpdate(role.guild.id, ["roles"]);
|
|
});
|
|
|
|
client.on("roleDelete", (role) => {
|
|
debounceStatsUpdate(role.guild.id, ["roles"]);
|
|
});
|
|
|
|
// Salon créé/supprimé -> channels
|
|
client.on("channelCreate", (channel) => {
|
|
if (channel.guild) debounceStatsUpdate(channel.guild.id, ["channels"]);
|
|
});
|
|
|
|
client.on("channelDelete", (channel) => {
|
|
if (channel.guild) debounceStatsUpdate(channel.guild.id, ["channels"]);
|
|
});
|
|
|
|
// Mise à jour du serveur -> boosts, boost_level
|
|
client.on("guildUpdate", (oldGuild, newGuild) => {
|
|
const types = [];
|
|
if (oldGuild.premiumSubscriptionCount !== newGuild.premiumSubscriptionCount) {
|
|
types.push("boosts");
|
|
}
|
|
if (oldGuild.premiumTier !== newGuild.premiumTier) {
|
|
types.push("boost_level");
|
|
}
|
|
if (types.length > 0) {
|
|
debounceStatsUpdate(newGuild.id, types);
|
|
}
|
|
});
|
|
|
|
// Mise à jour membre (rôle ajouté/retiré) -> role_members
|
|
client.on("guildMemberUpdate", (oldMember, newMember) => {
|
|
const oldRoles = oldMember.roles.cache;
|
|
const newRoles = newMember.roles.cache;
|
|
if (oldRoles.size !== newRoles.size || !oldRoles.every((r, id) => newRoles.has(id))) {
|
|
debounceStatsUpdate(newMember.guild.id, ["role_members"]);
|
|
}
|
|
});
|
|
|
|
// Au démarrage du bot -> toutes les stats
|
|
client.once("clientReady", async () => {
|
|
console.log("📊 Mise à jour initiale des salons de statistiques...");
|
|
await updateStatsChannels();
|
|
});
|
|
|
|
|
|
// ===== SCHEDULED MESSAGES SYSTEM =====
|
|
const { EmbedBuilder } = require("discord.js");
|
|
|
|
// Track last channel activity
|
|
const channelLastActivity = new Map();
|
|
|
|
// Update last activity on message
|
|
client.on("messageCreate", (message) => {
|
|
if (!message.guild || message.author.bot) return;
|
|
channelLastActivity.set(message.channel.id, Date.now());
|
|
});
|
|
|
|
// Process scheduled messages
|
|
async function processScheduledMessages() {
|
|
try {
|
|
const messages = await db.allAsync(
|
|
"SELECT * FROM scheduled_messages WHERE enabled = 1"
|
|
);
|
|
|
|
// Utiliser le fuseau horaire français
|
|
const now = new Date();
|
|
const parisTime = new Date(now.toLocaleString("en-US", { timeZone: "Europe/Paris" }));
|
|
const currentDay = parisTime.getDay(); // 0-6 (Sunday-Saturday)
|
|
const currentHour = parisTime.getHours().toString().padStart(2, '0');
|
|
const currentMinute = parisTime.getMinutes().toString().padStart(2, '0');
|
|
const currentTime = `${currentHour}:${currentMinute}`;
|
|
const currentTimestamp = Date.now();
|
|
|
|
for (const msg of messages) {
|
|
try {
|
|
const guild = client.guilds.cache.get(msg.guild_id);
|
|
if (!guild) continue;
|
|
|
|
const channel = guild.channels.cache.get(msg.channel_id);
|
|
if (!channel) continue;
|
|
|
|
let shouldSend = false;
|
|
|
|
if (msg.schedule_type === "weekly") {
|
|
// Check day and time
|
|
const days = JSON.parse(msg.days_of_week || "[]").map(d => parseInt(d));
|
|
const times = JSON.parse(msg.times_of_day || "[]");
|
|
|
|
if (days.includes(currentDay) && times.includes(currentTime)) {
|
|
// Check if already sent this minute
|
|
const lastSent = msg.last_sent_at || 0;
|
|
const oneMinuteAgo = currentTimestamp - 60000;
|
|
|
|
if (lastSent < oneMinuteAgo) {
|
|
shouldSend = true;
|
|
}
|
|
}
|
|
} else if (msg.schedule_type === "interval") {
|
|
// Check interval
|
|
const intervalMs = msg.interval_unit === "hours"
|
|
? msg.interval_value * 60 * 60 * 1000
|
|
: msg.interval_value * 60 * 1000;
|
|
|
|
const lastSent = msg.last_sent_at || 0;
|
|
|
|
if (currentTimestamp - lastSent >= intervalMs) {
|
|
shouldSend = true;
|
|
}
|
|
}
|
|
|
|
if (!shouldSend) continue;
|
|
|
|
// Check force_send option
|
|
if (!msg.force_send) {
|
|
const lastActivity = channelLastActivity.get(msg.channel_id) || msg.last_channel_activity || 0;
|
|
const lastSent = msg.last_sent_at || 0;
|
|
|
|
// If no activity since last send, skip
|
|
if (lastActivity <= lastSent) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Delete previous message if option enabled
|
|
if (msg.delete_previous && msg.last_message_id) {
|
|
try {
|
|
const oldMessage = await channel.messages.fetch(msg.last_message_id);
|
|
if (oldMessage) await oldMessage.delete();
|
|
} catch (err) {
|
|
// Message may have been deleted already
|
|
}
|
|
}
|
|
|
|
// Build message content
|
|
const messageOptions = {};
|
|
|
|
if (msg.message_content && msg.message_content.trim()) {
|
|
messageOptions.content = msg.message_content;
|
|
}
|
|
|
|
if (msg.embed_enabled) {
|
|
const embed = new EmbedBuilder();
|
|
|
|
if (msg.embed_title) embed.setTitle(msg.embed_title);
|
|
if (msg.embed_description) embed.setDescription(msg.embed_description);
|
|
if (msg.embed_color) {
|
|
const color = msg.embed_color.startsWith('#')
|
|
? parseInt(msg.embed_color.slice(1), 16)
|
|
: parseInt(msg.embed_color, 16);
|
|
embed.setColor(color);
|
|
}
|
|
embed.setTimestamp();
|
|
|
|
messageOptions.embeds = [embed];
|
|
}
|
|
|
|
// Send message
|
|
const sentMessage = await channel.send(messageOptions);
|
|
|
|
// Update database
|
|
db.run(
|
|
`UPDATE scheduled_messages SET
|
|
last_sent_at = ?,
|
|
last_message_id = ?,
|
|
last_channel_activity = ?
|
|
WHERE id = ?`,
|
|
[currentTimestamp, sentMessage.id, channelLastActivity.get(msg.channel_id) || currentTimestamp, msg.id]
|
|
);
|
|
|
|
console.log(`📨 Message programmé envoyé: ${msg.id} dans ${channel.name}`);
|
|
|
|
} catch (err) {
|
|
console.error(`Erreur envoi message programmé ${msg.id}:`, err);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error("Erreur processScheduledMessages:", err);
|
|
}
|
|
}
|
|
|
|
// Run every minute to check scheduled messages
|
|
setInterval(processScheduledMessages, 60 * 1000);
|
|
|
|
// Initial run after 10 seconds
|
|
setTimeout(processScheduledMessages, 10 * 1000);
|
|
|
|
|
|
client.login(process.env.BOT_TOKEN);
|
|
|
|
module.exports = client;
|
|
module.exports.updateGuildStats = updateGuildStats;
|