converted ShaiBot casino to Nut Economy

events/timerComplete.js

@@ -1,4 +1,4 @@
-const { mClient } = require("..");
+const { mClient } = require('..');
 
 async function getMember(client, userId) {
 	const guild = client.guilds.cache.get(process.env.D_GuildID);
@@ -7,15 +7,89 @@ async function getMember(client, userId) {
 		return null;
 	}
 
-	// Cache first
-	let member = guild.members.cache.get(userId);
-
-	// Fallback to API fetch
-	if (!member) {
-		member = await guild.members.fetch(userId).catch(() => null);
+	return (
+		guild.members.cache.get(userId) ||
+		await guild.members.fetch(userId).catch(() => null)
+	);
+}
+function getParticipantWeight(participant, now = Date.now()) {
+	// Never selected before -> strongly favor them
+	if (!participant.lastExpertAt) {
+		return 6;
 	}
 
-	return member;
+	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);
 }
 
 module.exports = {
@@ -35,50 +109,55 @@ module.exports = {
 			return;
 		}
 
-		// Notify previous assignee via DM
-		const previousMember = await getMember(client, timer.assignedUser);
+		// Notify previous expert
+		const previousMember = await getMember(
+			client,
+			timer.assignedUser
+		);
 
 		if (previousMember) {
 			await previousMember.send(
 				`❌ Timer ran out: **${timer.topic}** ...Re-assigning randomly...`
-			).catch(() => {});
+			).catch(error => {
+				console.error(
+					`timerComplete: Failed to DM ${timer.assignedUser}:`,
+					error
+				);
+			});
 		}
 
-		// Find the configured WGE channel
+		// Get configured WGE channel
 		const wgeChannelConfig = await channelColl.findOne({
 			purpose: 'wge',
 			guildID: process.env.D_GuildID
 		});
 
 		if (!wgeChannelConfig) {
-			console.error('timerComplete: WGE channel configuration not found.');
+			console.error(
+				'timerComplete: WGE channel configuration not found.'
+			);
 			return;
 		}
 
-		const channel = client.channels.cache.get(wgeChannelConfig.channelID);
+		const channel = client.channels.cache.get(
+			wgeChannelConfig.channelID
+		);
 
 		if (!channel) {
 			console.error('timerComplete: WGE channel not found.');
 			return;
 		}
 
-		// Pick a random participant, excluding the previous assignee
-		const randomParticipant = await participateColl.aggregate([
+		// Weighted random selection.
+		// Previous expert is explicitly excluded.
+		const selectedParticipant = await selectWgeParticipant(
+			participateColl,
 			{
-				$match: {
-					status: true,
-					userID: { $ne: timer.assignedUser }
-				}
-			},
-			{
-				$sample: {
-					size: 1
-				}
+				excludeUserId: timer.assignedUser
 			}
-		]).toArray();
+		);
 
-		// Nobody else is available
-		if (!randomParticipant.length) {
+		if (!selectedParticipant) {
 			await channel.send({
 				content:
 					`The timer for <@${timer.assignedUser}> has run out, ` +
@@ -89,12 +168,12 @@ module.exports = {
 		}
 
 		const newMember = await guild.members
-			.fetch(randomParticipant[0].userID)
+			.fetch(selectedParticipant.userID)
 			.catch(() => null);
 
 		if (!newMember) {
 			console.error(
-				`timerComplete: Could not fetch selected user ${randomParticipant[0].userID}.`
+				`timerComplete: Could not fetch selected user ${selectedParticipant.userID}.`
 			);
 			return;
 		}
@@ -102,14 +181,36 @@ module.exports = {
 		const newAssignedUser = newMember.user;
 
 		const wgeDefaultAssignedTime =
-			7 * 24 * 60 * 60 * 1000; // 7 days
+			7 * 24 * 60 * 60 * 1000;
 
-		// Remove the expired timer specifically
+		const assignedAt = new Date();
+
+		/*
+		 * Update participant statistics.
+		 *
+		 * $inc automatically creates expertCount with value 1
+		 * if the field does not exist yet.
+		 */
+		await participateColl.updateOne(
+			{
+				_id: selectedParticipant._id
+			},
+			{
+				$set: {
+					lastExpertAt: assignedAt
+				},
+				$inc: {
+					expertCount: 1
+				}
+			}
+		);
+
+		// Remove the expired timer
 		await wgeColl.deleteOne({
 			_id: timer._id
 		});
 
-		// Create the new timer
+		// Create new timer
 		await wgeColl.insertOne({
 			assignedUser: newAssignedUser.id,
 			assigningUser: timer.assigningUser,
@@ -128,14 +229,17 @@ module.exports = {
 			topic: timer.topic,
 			debug: false,
 
-			createdAt: new Date()
+			createdAt: assignedAt
 		});
 
-		// Announce reassignment
 		await channel.send({
 			content:
 				`The timer for <@${timer.assignedUser}> has run out! Assigning randomly...\n` +
 				`<@${newAssignedUser.id}> is the next expert! Their topic is still **${timer.topic}**`
 		});
+
+		console.log(
+			`timerComplete: Reassigned WGE from ${timer.assignedUser} to ${newAssignedUser.id}.`
+		);
 	}
 };