converted ShaiBot casino to Nut Economy

events/InteractionCreate.js

@@ -60,83 +60,199 @@ async function selectMenuHandler(interaction) {
     }
 }
 
+function getParticipantWeight(participant, now = Date.now()) {
+    // Never selected before -> strongly favor them
+    if (!participant.lastExpertAt) {
+        return 6;
+    }
+
+    const lastExpertAt = new Date(participant.lastExpertAt).getTime();
+
+    // Invalid date safety
+    if (Number.isNaN(lastExpertAt)) {
+        return 6;
+    }
+
+    const daysSinceExpert = Math.max(
+        0,
+        (now - lastExpertAt) / (24 * 60 * 60 * 1000)
+    );
+
+    /*
+     * Square-root weighting prevents very old participants
+     * from completely dominating the random selection.
+     *
+     * Examples:
+     *  1 day  -> ~1.41
+     *  7 days -> ~2.83
+     * 30 days -> ~5.57
+     */
+    return Math.sqrt(daysSinceExpert + 1);
+}
+
+function weightedRandom(participants) {
+    if (!participants.length) {
+        return null;
+    }
+
+    const weightedParticipants = participants.map(participant => ({
+        participant,
+        weight: getParticipantWeight(participant)
+    }));
+
+    const totalWeight = weightedParticipants.reduce(
+        (total, item) => total + item.weight,
+        0
+    );
+
+    let random = Math.random() * totalWeight;
+
+    for (const item of weightedParticipants) {
+        random -= item.weight;
+
+        if (random <= 0) {
+            return item.participant;
+        }
+    }
+
+    // Floating-point safety fallback
+    return weightedParticipants[weightedParticipants.length - 1].participant;
+}
+
+async function selectWgeParticipant(
+    participateColl,
+    { excludeUserId = null } = {}
+) {
+    const filter = {
+        status: true
+    };
+
+    if (excludeUserId) {
+        filter.userID = {
+            $ne: excludeUserId
+        };
+    }
+
+    const participants = await participateColl
+        .find(filter)
+        .toArray();
+
+    return weightedRandom(participants);
+}
+
 async function modalSubmitHandler(interaction) {
-    if (interaction.customId !== 'wgeBaseModal') return;
+    if (interaction.customId !== 'wgeBaseModal') {
+        return;
+    }
 
     const db = mClient.db('neo-db');
+
     const wgeColl = db.collection('timer_wge');
     const participateColl = db.collection('items_wge');
     const historyWgeColl = db.collection('history_wge');
 
     const assigningUser = interaction.user;
-    const selectedUserId = interaction.components[0].component.values[0];
-    const topic = interaction.fields.getTextInputValue('wgeTopicInput');
-    const defaultAssignedTime = 7 * 24 * 60 * 60 * 1000; // 7 days
 
-    // Get current running WGE so we can exclude the current expert
+    const selectedUserId =
+        interaction.components[0].component.values[0];
+
+    const topic = interaction.fields.getTextInputValue(
+        'wgeTopicInput'
+    );
+
+    const defaultAssignedTime =
+        7 * 24 * 60 * 60 * 1000;
+
+    // Get current running WGE so the previous expert
+    // cannot immediately be selected again.
     const prevWge = await wgeColl.findOne({
         debug: false,
         state: 'running'
     });
 
     let assignedUser;
+    let selectedParticipant;
 
-    // Random assignment
+    // ---------------------------------
+    // RANDOM / WEIGHTED ASSIGNMENT
+    // ---------------------------------
     if (selectedUserId === process.env.D_ID) {
-        const randomParticipant = await participateColl.aggregate([
+        selectedParticipant = await selectWgeParticipant(
+            participateColl,
             {
-                $match: {
-                    status: true,
-                    ...(prevWge && {
-                        userID: { $ne: prevWge.assignedUser }
-                    })
-                }
-            },
-            { $sample: { size: 1 } }
-        ]).toArray();
+                excludeUserId: prevWge?.assignedUser
+            }
+        );
 
-        if (randomParticipant.length === 0) {
+        if (!selectedParticipant) {
             return interaction.reply({
-                content: 'There are no eligible participants available.',
+                content:
+                    'There are no eligible participants available.',
+                flags: MessageFlags.Ephemeral
+            });
+        }
+
+        const member = await interaction.guild.members
+            .fetch(selectedParticipant.userID)
+            .catch(() => null);
+
+        if (!member) {
+            return interaction.reply({
+                content:
+                    'The selected participant could not be found in the server.',
                 flags: MessageFlags.Ephemeral
             });
         }
 
-        const member = await interaction.guild.members.fetch(randomParticipant[0].userID);
         assignedUser = member.user;
     }
-    // Manual assignment
+
+    // ---------------------------------
+    // MANUAL ASSIGNMENT
+    // ---------------------------------
     else {
-        const participant = await participateColl.findOne({
+        selectedParticipant = await participateColl.findOne({
             userID: selectedUserId,
             status: true
         });
 
-        if (!participant) {
+        if (!selectedParticipant) {
             return interaction.reply({
-                content: `<@${selectedUserId}> is not participating!`,
+                content:
+                    `<@${selectedUserId}> is not participating!`,
                 flags: MessageFlags.Ephemeral
             });
         }
 
-        if (prevWge && selectedUserId === prevWge.assignedUser) {
+        if (
+            prevWge &&
+            selectedUserId === prevWge.assignedUser
+        ) {
             return interaction.reply({
-                content: `<@${selectedUserId}> was the previous expert and cannot be selected again this round.`,
+                content:
+                    `<@${selectedUserId}> was the previous expert and cannot be selected again this round.`,
                 flags: MessageFlags.Ephemeral
             });
         }
 
-        assignedUser = { id: selectedUserId };
+        assignedUser = {
+            id: selectedUserId
+        };
     }
 
-    // Archive previous WGE
+    // ---------------------------------
+    // ARCHIVE PREVIOUS WGE
+    // ---------------------------------
     if (prevWge) {
         await historyWgeColl.insertOne({
             assignedUser: prevWge.assignedUser,
             assigningUser: prevWge.assigningUser,
+
             timeRemaining: prevWge.timeRemaining,
+
             topic: prevWge.topic,
             debug: prevWge.debug,
+
             createdAt: prevWge.createdAt
         });
 
@@ -150,7 +266,28 @@ async function modalSubmitHandler(interaction) {
         });
     }
 
-    // Create new WGE
+    const assignedAt = new Date();
+
+    // ---------------------------------
+    // UPDATE PARTICIPANT STATISTICS
+    // ---------------------------------
+    await participateColl.updateOne(
+        {
+            _id: selectedParticipant._id
+        },
+        {
+            $set: {
+                lastExpertAt: assignedAt
+            },
+            $inc: {
+                expertCount: 1
+            }
+        }
+    );
+
+    // ---------------------------------
+    // CREATE NEW WGE
+    // ---------------------------------
     await wgeColl.insertOne({
         assignedUser: assignedUser.id,
         assigningUser: assigningUser.id,
@@ -169,10 +306,11 @@ async function modalSubmitHandler(interaction) {
         topic,
         debug: false,
 
-        createdAt: new Date()
+        createdAt: assignedAt
     });
 
     return interaction.reply({
-        content: `<@${assignedUser.id}> is the next expert! Their topic is **${topic}**`
+        content:
+            `<@${assignedUser.id}> is the next expert! Their topic is **${topic}**`
     });
 }