jsdecryptor 4.0.3

package/davexcore/games/connect4.js

@@ -0,0 +1,267 @@
+const ConnectFour = require('../../davelib/connect4');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+// Store games globally
+const connectFourGames = {};
+async function connectFourCommand(sock, chatId, senderId, text, message) {
+    try {
+        const fake = createFakeContact(message || { key: { participant: senderId, remoteJid: chatId } });
+        
+        // Check if player is already in a game
+        const existingGame = Object.values(connectFourGames).find(room => 
+            room.id && room.id.startsWith('connectfour') && 
+            (room.game.playerRed === senderId || room.game.playerYellow === senderId) &&
+            room.state !== 'ENDED'
+        );
+
+        if (existingGame) {
+            await sock.sendMessage(chatId, { 
+                text: 'You are already in a Connect Four game. Type .forfeit to quit.' 
+            }, { quoted: fake });
+            return;
+        }
+
+        // Clean up old games
+        Object.keys(connectFourGames).forEach(id => {
+            if (connectFourGames[id].state === 'ENDED' || Date.now() - parseInt(id.split('-')[1]) > 3600000) {
+                delete connectFourGames[id];
+            }
+        });
+
+        // Look for existing room to join
+        let room = Object.values(connectFourGames).find(room => 
+            room.id && 
+            room.id.startsWith('connectfour') && 
+            room.state === 'WAITING' && 
+            (!text || room.name === text) &&
+            room.red !== chatId // Prevent joining your own waiting room
+        );
+
+        if (room) {
+            // Join existing room
+            room.yellow = chatId;
+            room.game.playerYellow = senderId;
+            room.state = 'PLAYING';
+
+            const board = room.game.render();
+            const str = `Connect Four Game Started!
+
+Waiting for @${room.game.currentTurn.split('@')[0]} to make a move...
+
+${board}
+
+Room ID: ${room.id}
+Rules:
+Use .drop <column> to drop your disc (1-7)
+Connect 4 discs horizontally, vertically, or diagonally to win
+Type .forfeit to give up
+
+Red Player: @${room.game.playerRed.split('@')[0]}
+Yellow Player: @${room.game.playerYellow.split('@')[0]}
+`;
+
+            await sock.sendMessage(chatId, { 
+                text: str,
+                mentions: [room.game.currentTurn, room.game.playerRed, room.game.playerYellow]
+            }, { quoted: fake });
+
+            // Also notify the creator
+            if (room.red !== chatId) {
+                const creatorFake = createFakeContact({ key: { participant: senderId, remoteJid: room.red } });
+                await sock.sendMessage(room.red, { 
+                    text: 'Opponent found! Connect Four game has started.'
+                }, { quoted: creatorFake });
+            }
+
+        } else {
+            // Create new room
+            room = {
+                id: 'connectfour-' + Date.now(),
+                red: chatId,
+                yellow: '',
+                game: new ConnectFour(senderId, 'yellow'), // Creator is red
+                state: 'WAITING'
+            };
+
+            // Store game type/name if provided
+            if (text) room.name = text;
+
+            connectFourGames[room.id] = room;
+
+            await sock.sendMessage(chatId, { 
+                text: `Waiting for Connect Four opponent...\nType .connectfour${text ? ' ' + text : ''} to join!\n\nYou will be Red. Room will expire in 5 minutes.\n\nCommands:\n.drop <1-7> - Drop disc in column\n.forfeit - Give up`
+            }, { quoted: fake });
+
+            // Auto-cleanup after 5 minutes if no one joins
+            setTimeout(() => {
+                if (connectFourGames[room.id] && connectFourGames[room.id].state === 'WAITING') {
+                    delete connectFourGames[room.id];
+                    const cleanupFake = createFakeContact({ key: { participant: senderId, remoteJid: chatId } });
+                    sock.sendMessage(chatId, { 
+                        text: 'Room expired. No one joined the Connect Four game.' 
+                    }, { quoted: cleanupFake }).catch(() => {});
+                }
+            }, 300000); // 5 minutes
+
+        }
+
+    } catch (error) {
+        console.error('Error in connectfour command:', error);
+        const fake = createFakeContact(message || { key: { participant: senderId, remoteJid: chatId } });
+        await sock.sendMessage(chatId, { 
+            text: 'Error starting Connect Four game. Please try again.' 
+        }, { quoted: fake });
+    }
+}
+
+async function handleConnectFourMove(sock, chatId, senderId, columnText, message) {
+    try {
+        const fake = createFakeContact(message || { key: { participant: senderId, remoteJid: chatId } });
+        
+        // Find player's game
+        const room = Object.values(connectFourGames).find(room => 
+            room.id && 
+            room.id.startsWith('connectfour') && 
+            (room.game.playerRed === senderId || room.game.playerYellow === senderId) && 
+            room.state === 'PLAYING'
+        );
+
+        if (!room) return false; // Return false if no game found
+
+        const isForfeit = /^(forfeit|give up|quit|resign|surrender)$/i.test(columnText);
+        const column = parseInt(columnText);
+
+        // If not a valid move command and not forfeit, ignore
+        if (!isForfeit && (isNaN(column) || column < 1 || column > 7)) return false;
+
+        // Check if it's player's turn (except for forfeit)
+        if (senderId !== room.game.currentTurn && !isForfeit) {
+            await sock.sendMessage(chatId, { 
+                text: 'Not your turn! Wait for your opponent to move.' 
+            }, { quoted: fake });
+            return true;
+        }
+
+        let moveResult;
+        if (isForfeit) {
+            moveResult = true; // Allow forfeit
+        } else {
+            try {
+                moveResult = room.game.dropDisc(
+                    senderId === room.game.playerYellow, // true if player is yellow
+                    column - 1 // Convert to 0-indexed
+                );
+            } catch (error) {
+                console.error('Move error:', error);
+                await sock.sendMessage(chatId, { 
+                    text: 'Invalid column! Please use .drop 1 to .drop 7.' 
+                }, { quoted: fake });
+                return true;
+            }
+        }
+
+        if (!moveResult && !isForfeit) {
+            await sock.sendMessage(chatId, { 
+                text: 'Column is full! Choose another column.' 
+            }, { quoted: fake });
+            return true;
+        }
+
+        let winner = null;
+        let isDraw = false;
+
+        if (isForfeit) {
+            // Set winner to opponent
+            winner = senderId === room.game.playerRed ? room.game.playerYellow : room.game.playerRed;
+            room.state = 'ENDED';
+
+            const forfeitMessage = `@${senderId.split('@')[0]} has forfeited!\n@${winner.split('@')[0]} wins the Connect Four game!`;
+
+            // Send to both players
+            const mentions = [senderId, winner];
+            await sock.sendMessage(room.red, { 
+                text: forfeitMessage,
+                mentions: mentions
+            }, { quoted: fake });
+
+            if (room.yellow && room.red !== room.yellow) {
+                await sock.sendMessage(room.yellow, { 
+                    text: forfeitMessage,
+                    mentions: mentions
+                }, { quoted: fake });
+            }
+
+            delete connectFourGames[room.id];
+            return true;
+        }
+
+        // Check game status
+        winner = room.game.winner || null;
+        isDraw = room.game.isDraw();
+
+        const board = room.game.render();
+        let gameStatus;
+        if (winner) {
+            const winnerSymbol = winner === room.game.playerRed ? 'Red' : 'Yellow';
+            gameStatus = `@${winner.split('@')[0]} wins by connecting four!`;
+            room.state = 'ENDED';
+        } else if (isDraw) {
+            gameStatus = `Game ended in a draw! Board is full.`;
+            room.state = 'ENDED';
+        } else {
+            gameStatus = `Turn: @${room.game.currentTurn.split('@')[0]}`;
+        }
+
+        const str = `Connect Four Game
+
+${gameStatus}
+
+${board}
+
+Red Player: @${room.game.playerRed.split('@')[0]}
+Yellow Player: @${room.game.playerYellow.split('@')[0]}
+
+${!winner && !isDraw ? 'Use .drop <1-7> to make your move\nType .forfeit to give up' : 'Type .connectfour to start a new game'}
+`;
+
+        const mentions = [
+            room.game.playerRed, 
+            room.game.playerYellow,
+            ...(winner ? [winner] : [room.game.currentTurn])
+        ];
+
+        // Send to both players
+        await sock.sendMessage(room.red, { 
+            text: str,
+            mentions: mentions
+        }, { quoted: fake });
+
+        if (room.yellow && room.red !== room.yellow) {
+            await sock.sendMessage(room.yellow, { 
+                text: str,
+                mentions: mentions
+            }, { quoted: fake });
+        }
+
+        if (winner || isDraw) {
+            delete connectFourGames[room.id];
+        }
+
+        return true;
+
+    } catch (error) {
+        console.error('Error in connectfour move:', error);
+        try {
+            const fake = createFakeContact(message || { key: { participant: senderId, remoteJid: chatId } });
+            await sock.sendMessage(chatId, { 
+                text: 'An error occurred during the move. Please start a new game.' 
+            }, { quoted: fake });
+        } catch (e) {}
+        return true;
+    }
+}
+
+module.exports = {
+    connectFourCommand,
+    handleConnectFourMove
+};

package/davexcore/games/dice.js

@@ -0,0 +1,286 @@
+const DiceGame = require('../../davelib/dicegame');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const games = {};
+const gameTimeouts = {};
+
+function getPlayerName(jid) {
+    return (jid || '').split(':')[0].split('@')[0];
+}
+
+function clearDiceTimeout(chatId) {
+    if (gameTimeouts[chatId]) {
+        clearTimeout(gameTimeouts[chatId]);
+        delete gameTimeouts[chatId];
+    }
+}
+
+async function diceCommand(sock, chatId, senderId, fullArgs) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (games[chatId] && games[chatId].state !== 'ENDED') {
+            const g = games[chatId];
+            const players = g.players.map(p => `@${getPlayerName(p)}`).join(', ');
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}* Dice\n\nGame active!\nPlayers: ${players}\nRound: ${g.round}/${g.maxRounds}\n\nUse .roll | .diceend`,
+                mentions: g.players
+            }, { quoted: fake });
+            return;
+        }
+
+        const rounds = parseInt(fullArgs) || 3;
+        const maxRounds = Math.min(Math.max(rounds, 1), 10);
+
+        games[chatId] = new DiceGame(senderId, maxRounds);
+
+        clearDiceTimeout(chatId);
+        gameTimeouts[chatId] = setTimeout(() => {
+            if (games[chatId] && games[chatId].state === 'WAITING') {
+                delete games[chatId];
+                sock.sendMessage(chatId, {
+                    text: `✦ *${botName}*\nGame expired - no one joined`
+                }).catch(() => {});
+            }
+        }, 120000);
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* Dice\n\n@${getPlayerName(senderId)} started a game!\n\nRounds: ${maxRounds}\n\nJoin: .dicejoin\nStart: .dicebegin\nRoll: .roll`,
+            mentions: [senderId]
+        }, { quoted: fake });
+    } catch (err) {
+        console.error('Dice command error:', err);
+    }
+}
+
+async function diceAICommand(sock, chatId, senderId, fullArgs) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+
+        if (games[chatId] && games[chatId].state !== 'ENDED') {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nGame active! Use .diceend first`
+            }, { quoted: fake });
+            return;
+        }
+
+        const rounds = parseInt(fullArgs) || 3;
+        const maxRounds = Math.min(Math.max(rounds, 1), 10);
+        const botJid = 'bot@s.whatsapp.net';
+
+        const game = new DiceGame(senderId, maxRounds);
+        game.addPlayer(botJid);
+        game.start();
+        games[chatId] = game;
+
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* Dice vs AI\n\n@${getPlayerName(senderId)} vs Bot\nRounds: ${maxRounds}\n\nYour turn! .roll`,
+            mentions: [senderId]
+        }, { quoted: fake });
+    } catch (err) {
+        console.error('Dice AI error:', err);
+    }
+}
+
+async function handleDiceJoin(sock, chatId, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const game = games[chatId];
+
+        if (!game || game.state !== 'WAITING') {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nNo game waiting. Start with .dice`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!game.addPlayer(senderId)) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nYou're already in!`
+            }, { quoted: fake });
+            return;
+        }
+
+        const players = game.players.map(p => `@${getPlayerName(p)}`).join(', ');
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* Dice\n\n@${getPlayerName(senderId)} joined!\nPlayers (${game.players.length}): ${players}\n\n.dicebegin to start`,
+            mentions: game.players
+        }, { quoted: fake });
+    } catch (err) {
+        console.error('Dice join error:', err);
+    }
+}
+
+async function handleDiceBegin(sock, chatId, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const game = games[chatId];
+
+        if (!game || game.state !== 'WAITING') {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nNo game to start`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (senderId !== game.host) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nOnly host can start`
+            }, { quoted: fake });
+            return;
+        }
+
+        if (!game.start()) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nNeed at least 2 players`
+            }, { quoted: fake });
+            return;
+        }
+
+        clearDiceTimeout(chatId);
+
+        const players = game.players.map(p => `@${getPlayerName(p)}`).join(', ');
+        await sock.sendMessage(chatId, {
+            text: `✦ *${botName}* Game Started\n\nPlayers: ${players}\nRounds: ${game.maxRounds}\n\n@${getPlayerName(game.currentPlayer)}'s turn! .roll`,
+            mentions: game.players
+        }, { quoted: fake });
+    } catch (err) {
+        console.error('Dice begin error:', err);
+    }
+}
+
+async function handleDiceRoll(sock, chatId, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const game = games[chatId];
+        const botJid = 'bot@s.whatsapp.net';
+
+        if (!game || game.state !== 'PLAYING') {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nNo active game. Start with .dice`
+            }, { quoted: fake });
+            return;
+        }
+
+        const result = game.roll(senderId);
+        if (!result.ok) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\n${result.reason}`
+            }, { quoted: fake });
+            return;
+        }
+
+        let msg = `✦ *${botName}* Dice\n\n` +
+                  `@${getPlayerName(senderId)} rolled:\n` +
+                  `[ ${result.dice1} ] + [ ${result.dice2} ] = *${result.total}*\n`;
+
+        if (result.gameOver) {
+            const winner = game.winner;
+            msg += `\n*GAME OVER*\n\n${game.getScoreboard()}\n\n` +
+                   `Winner: @${getPlayerName(winner)}!`;
+            delete games[chatId];
+            clearDiceTimeout(chatId);
+            await sock.sendMessage(chatId, {
+                text: msg,
+                mentions: game.players
+            }, { quoted: fake });
+        } else if (result.roundComplete) {
+            msg += `\n*Round ${result.round} complete*\n\n${game.getScoreboard()}\n\n` +
+                   `Round ${game.round}/${game.maxRounds} - @${getPlayerName(result.nextPlayer)}'s turn! .roll`;
+
+            if (result.nextPlayer === botJid) {
+                await sock.sendMessage(chatId, { text: msg, mentions: game.players }, { quoted: fake });
+                await new Promise(r => setTimeout(r, 1500));
+                await handleBotDiceRoll(sock, chatId, game, botJid);
+            } else {
+                await sock.sendMessage(chatId, { text: msg, mentions: game.players }, { quoted: fake });
+            }
+        } else {
+            if (result.nextPlayer === botJid) {
+                msg += `\nBot's turn...`;
+                await sock.sendMessage(chatId, { text: msg, mentions: [senderId] }, { quoted: fake });
+                await new Promise(r => setTimeout(r, 1500));
+                await handleBotDiceRoll(sock, chatId, game, botJid);
+            } else {
+                msg += `\n@${getPlayerName(result.nextPlayer)}'s turn! .roll`;
+                await sock.sendMessage(chatId, { text: msg, mentions: [senderId, result.nextPlayer] }, { quoted: fake });
+            }
+        }
+    } catch (err) {
+        console.error('Dice roll error:', err);
+    }
+}
+
+async function handleBotDiceRoll(sock, chatId, game, botJid) {
+    const botName = getBotName();
+    const result = game.roll(botJid);
+    if (!result.ok) return;
+
+    let msg = `✦ *${botName}* Bot Roll\n\n` +
+              `Bot rolled:\n[ ${result.dice1} ] + [ ${result.dice2} ] = *${result.total}*\n`;
+
+    if (result.gameOver) {
+        const winner = game.winner;
+        msg += `\n*GAME OVER*\n\n${game.getScoreboard()}\n\n` +
+               `Winner: ${winner === botJid ? 'Bot' : `@${getPlayerName(winner)}`}!`;
+        delete games[chatId];
+        clearDiceTimeout(chatId);
+        await sock.sendMessage(chatId, { text: msg, mentions: game.players });
+    } else if (result.roundComplete) {
+        msg += `\n*Round ${result.round} complete*\n\n${game.getScoreboard()}\n\n` +
+               `Round ${game.round}/${game.maxRounds} - @${getPlayerName(result.nextPlayer)}'s turn! .roll`;
+        await sock.sendMessage(chatId, { text: msg, mentions: game.players });
+    } else {
+        msg += `\n@${getPlayerName(result.nextPlayer)}'s turn! .roll`;
+        await sock.sendMessage(chatId, { text: msg, mentions: [result.nextPlayer] });
+    }
+}
+
+async function diceEndCommand(sock, chatId, senderId) {
+    try {
+        const fake = createFakeContact(senderId);
+        const botName = getBotName();
+        const game = games[chatId];
+
+        if (!game) {
+            await sock.sendMessage(chatId, {
+                text: `✦ *${botName}*\nNo active game`
+            }, { quoted: fake });
+            return;
+        }
+
+        let msg = `✦ *${botName}*\nGame ended by @${getPlayerName(senderId)}.`;
+        if (game.state === 'PLAYING') {
+            msg += `\n\n${game.getScoreboard()}`;
+        }
+
+        delete games[chatId];
+        clearDiceTimeout(chatId);
+
+        await sock.sendMessage(chatId, {
+            text: msg,
+            mentions: game.players
+        }, { quoted: fake });
+    } catch (err) {
+        console.error('Dice end error:', err);
+    }
+}
+
+function hasDiceGame(chatId) {
+    return !!games[chatId] && games[chatId].state !== 'ENDED';
+}
+
+module.exports = {
+    diceCommand,
+    diceAICommand,
+    handleDiceJoin,
+    handleDiceBegin,
+    handleDiceRoll,
+    diceEndCommand,
+    hasDiceGame,
+};

package/davexcore/games/eightball.js

@@ -0,0 +1,24 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const eightBallResponses = [
+    "Yes, definitely!",
+    "No way!",
+    "Ask again later.",
+    "It is certain.",
+    "Very doubtful.",
+    "Without a doubt.",
+    "My reply is no.",
+    "Signs point to yes."
+];
+
+async function eightBallCommand(sock, chatId, question) {
+    if (!question) {
+        await sock.sendMessage(chatId, { text: 'Please ask a question!' });
+        return;
+    }
+
+    const randomResponse = eightBallResponses[Math.floor(Math.random() * eightBallResponses.length)];
+    await sock.sendMessage(chatId, { text: `🎱 ${randomResponse}` });
+}
+
+module.exports = { eightBallCommand };

package/davexcore/games/hangman.js

@@ -0,0 +1,60 @@
+const fs = require('fs');
+
+const words = ['javascript', 'bot', 'hangman', 'whatsapp', 'nodejs'];
+let hangmanGames = {};
+
+function startHangman(sock, chatId) {
+    const word = words[Math.floor(Math.random() * words.length)];
+    const maskedWord = '_ '.repeat(word.length).trim();
+
+    hangmanGames[chatId] = {
+        word,
+        maskedWord: maskedWord.split(' '),
+        guessedLetters: [],
+        wrongGuesses: 0,
+        maxWrongGuesses: 6,
+    };
+
+    sock.sendMessage(chatId, { text: `Game started! The word is: ${maskedWord}` });
+}
+
+function guessLetter(sock, chatId, letter) {
+    if (!hangmanGames[chatId]) {
+        sock.sendMessage(chatId, { text: 'No game in progress. Start a new game with .hangman' });
+        return;
+    }
+
+    const game = hangmanGames[chatId];
+    const { word, guessedLetters, maskedWord, maxWrongGuesses } = game;
+
+    if (guessedLetters.includes(letter)) {
+        sock.sendMessage(chatId, { text: `You already guessed "${letter}". Try another letter.` });
+        return;
+    }
+
+    guessedLetters.push(letter);
+
+    if (word.includes(letter)) {
+        for (let i = 0; i < word.length; i++) {
+            if (word[i] === letter) {
+                maskedWord[i] = letter;
+            }
+        }
+        sock.sendMessage(chatId, { text: `Good guess! ${maskedWord.join(' ')}` });
+
+        if (!maskedWord.includes('_')) {
+            sock.sendMessage(chatId, { text: `Congratulations! You guessed the word: ${word}` });
+            delete hangmanGames[chatId];
+        }
+    } else {
+        game.wrongGuesses += 1;
+        sock.sendMessage(chatId, { text: `Wrong guess! You have ${maxWrongGuesses - game.wrongGuesses} tries left.` });
+
+        if (game.wrongGuesses >= maxWrongGuesses) {
+            sock.sendMessage(chatId, { text: `Game over! The word was: ${word}` });
+            delete hangmanGames[chatId];
+        }
+    }
+}
+
+module.exports = { startHangman, guessLetter };

package/davexcore/games/rps.js

@@ -0,0 +1,25 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+function rpsCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const choices = ['rock', 'paper', 'scissors'];
+    const emojis = { rock: '🪨', paper: '📄', scissors: '✂️' };
+    
+    const userChoice = (args[0] || '').toLowerCase();
+    if (!choices.includes(userChoice)) {
+        return sock.sendMessage(chatId, { text: `*${botName} RPS*\n\nUsage: .rps <rock|paper|scissors>\nExample: .rps rock` }, { quoted: fakeContact });
+    }
+    
+    const botChoice = choices[Math.floor(Math.random() * 3)];
+    
+    let result;
+    if (userChoice === botChoice) result = "It's a TIE!";
+    else if ((userChoice === 'rock' && botChoice === 'scissors') || (userChoice === 'paper' && botChoice === 'rock') || (userChoice === 'scissors' && botChoice === 'paper')) result = 'You WIN!';
+    else result = 'You LOSE!';
+    
+    const text = `*${botName} RPS*\n\nYou: ${emojis[userChoice]} ${userChoice}\nBot: ${emojis[botChoice]} ${botChoice}\n\n*${result}*`;
+    return sock.sendMessage(chatId, { text }, { quoted: fakeContact });
+}
+
+module.exports = rpsCommand;

package/davexcore/games/ship.js

@@ -0,0 +1,36 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function shipCommand(sock, chatId, msg, groupMetadata) {
+    try {
+        const fakeContact = createFakeContact(msg);
+        // Get all participants from the group
+        const participants = await sock.groupMetadata(chatId);
+        const ps = participants.participants.map(v => v.id);
+        
+        // Get two random participants
+        let firstUser, secondUser;
+        
+        // Select first random user
+        firstUser = ps[Math.floor(Math.random() * ps.length)];
+        
+        // Select second random user (different from first)
+        do {
+            secondUser = ps[Math.floor(Math.random() * ps.length)];
+        } while (secondUser === firstUser);
+
+        // Format the mentions
+        const formatMention = id => '@' + id.split('@')[0];
+
+        // Create and send the ship message
+        await sock.sendMessage(chatId, {
+            text: `${formatMention(firstUser)} ❤️ ${formatMention(secondUser)}\nCongratulations 💖🍻`,
+            mentions: [firstUser, secondUser]
+        }, { quoted: fakeContact });
+
+    } catch (error) {
+        console.error('Error in ship command:', error);
+        await sock.sendMessage(chatId, { text: '❌ Failed to ship! Make sure this is a group.' }, { quoted: fakeContact });
+    }
+}
+
+module.exports = shipCommand;