dankgrinder 4.8.1 → 4.9.1

package/lib/commands/blackjack.js

@@ -5,33 +5,51 @@
 
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
 } = require('./utils');
 
-function parsePlayerTotal(text) {
-  // Match the player section: "username (Player)\n ♦ J ♦ 2  12"
-  // The number after the cards on the player line is the total
-  const playerSection = text.match(/\(Player\)[\s\S]*?(\d+)/i);
-  if (playerSection) return parseInt(playerSection[1]);
-  const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
-  return totalMatch ? parseInt(totalMatch[1]) : 0;
+function parsePlayerTotal(msg) {
+  // Score is in embed field: ` 18 ` (backtick-wrapped number in Player field)
+  for (const embed of msg?.embeds || []) {
+    for (const field of embed.fields || []) {
+      if (field.name?.toLowerCase().includes('player')) {
+        const m = field.value.match(/`\s*(\d+)\s*`/);
+        if (m) return parseInt(m[1]);
+      }
+    }
+  }
+  const text = typeof msg === 'string' ? msg : getFullText(msg);
+  const m = text.match(/`\s*(\d+)\s*`/);
+  return m ? parseInt(m[1]) : 0;
 }
 
-function parseDealerUpcard(text) {
-  // Match dealer section: "Dank Memer (Dealer)\n ♦ 10 ♣ 8  18"
-  const dealerSection = text.match(/\(Dealer\)[\s\S]*?(\d+)/i);
-  if (dealerSection) return parseInt(dealerSection[1]);
+function parseDealerUpcard(msg) {
+  // Dealer field: revealed total ` 18 ` or hidden ` ? `
+  // Upcard from emoji: bjFaceKB=K(10), bjFaceAR=A(11), bjFace7R=7
+  for (const embed of msg?.embeds || []) {
+    for (const field of embed.fields || []) {
+      if (field.name?.toLowerCase().includes('dealer')) {
+        const totalMatch = field.value.match(/`\s*(\d+)\s*`/);
+        if (totalMatch) return parseInt(totalMatch[1]);
+        const faces = [...field.value.matchAll(/bjFace(\w+?):/g)];
+        for (const [, face] of faces) {
+          if (face === 'Unknown') continue;
+          const v = face.replace(/[RB]$/, '');
+          if (v === 'A') return 11;
+          if (['K', 'Q', 'J'].includes(v)) return 10;
+          const n = parseInt(v);
+          if (!isNaN(n)) return n;
+        }
+      }
+    }
+  }
   return 0;
 }
 
 function parseNetCoins(text) {
-  // Parse "Net: ⏣ -5,000" or "Net: ⏣ 5,000"
-  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
-  if (netMatch) {
-    return parseInt(netMatch[1].replace(/,/g, ''));
-  }
-  // Parse "Winnings: ⏣ 5,000"
-  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  const netMatch = text.match(/Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i);
+  if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
+  const winMatch = text.match(/Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i);
   if (winMatch) return parseInt(winMatch[1].replace(/,/g, ''));
   return 0;
 }
@@ -63,6 +81,8 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
     return { result: 'no response', coins: 0 };
   }
 
+  await ensureCV2(current);
+
   if (isHoldTight(current)) {
     const reason = getHoldTightReason(current);
     LOG.warn(`[bj] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
@@ -74,25 +94,26 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
 
   const MAX_ROUNDS = 10;
   for (let i = 0; i < MAX_ROUNDS; i++) {
-    const text = getFullText(current);
-    const buttons = getAllButtons(current);
-    if (buttons.length === 0 || buttons.every(b => b.disabled)) break;
+    const buttons = getAllButtons(current).filter(b => b.label && b.label !== 'null');
+    const hitBtn = buttons.find(b => !b.disabled && (b.label || '').toLowerCase().includes('hit'));
+    const standBtn = buttons.find(b => !b.disabled && (b.label || '').toLowerCase().includes('stand'));
+    if (!hitBtn && !standBtn) break;
 
-    const playerTotal = parsePlayerTotal(text);
-    const dealerTotal = parseDealerUpcard(text);
+    const playerTotal = parsePlayerTotal(current);
+    const dealerUpcard = parseDealerUpcard(current);
 
     let targetBtn;
     if (playerTotal === 0) {
-      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
-    } else if (shouldHit(playerTotal, dealerTotal)) {
-      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('hit')) || buttons[0];
+      targetBtn = standBtn || hitBtn;
+    } else if (shouldHit(playerTotal, dealerUpcard)) {
+      targetBtn = hitBtn || standBtn;
     } else {
-      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
+      targetBtn = standBtn || hitBtn;
     }
 
-    if (!targetBtn || targetBtn.disabled) break;
+    if (!targetBtn) break;
 
-    LOG.info(`[bj] You:${playerTotal} Dealer:${dealerTotal} → ${targetBtn.label}`);
+    LOG.info(`[bj] You:${playerTotal} Dealer:${dealerUpcard} → ${targetBtn.label}`);
     await humanDelay(400, 900);
 
     try {
@@ -100,8 +121,6 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
       if (followUp) {
         current = followUp;
         logMsg(current, `bj-round-${i}`);
-        const fButtons = getAllButtons(current);
-        if (fButtons.length === 0 || fButtons.every(b => b.disabled)) break;
       } else break;
     } catch { break; }
   }

package/lib/commands/gamble.js

@@ -1,17 +1,16 @@
 /**
  * Gambling command handlers.
- * Covers: cointoss, roulette, slots, snakeeyes
+ * Covers: cointoss (CV2), roulette, slots, snakeeyes
+ * Each handler is tailored to the actual Dank Memer response format.
  */
 
 const {
   LOG, c, getFullText, parseCoins, parseNetCoins, getAllButtons, safeClickButton,
-  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, ensureCV2,
 } = require('./utils');
 
-function parseGambleResult(text, cmdName) {
+function parseResult(text, cmdName) {
   const net = parseNetCoins(text);
-  const lower = text.toLowerCase();
-
   if (net > 0) {
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${net.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${net.toLocaleString()}`, coins: net };
@@ -25,84 +24,188 @@ function parseGambleResult(text, cmdName) {
     LOG.coin(`[${cmdName}] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
     return { result: `${cmdName} → +⏣ ${coins.toLocaleString()}`, coins };
   }
-  if (lower.includes('won') || lower.includes('beat')) return { result: `${cmdName} → won`, coins: 0 };
-  if (lower.includes('lost') || lower.includes('bust')) return { result: `${cmdName} → lost`, coins: 0, lost: coins };
-
   return { result: `${cmdName} done`, coins: 0 };
 }
 
-async function runGamble({ channel, waitForDankMemer, cmdName, cmdString }) {
-  LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
+function checkMinBet(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("can't bet less than") || lower.includes('cannot bet less than') || lower.includes('minimum bet')) {
+    const m = text.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || text.match(/(\d[\d,]+)/);
+    if (m) return parseInt(m[1].replace(/,/g, ''));
+    return -1;
+  }
+  return 0;
+}
 
-  await channel.send(cmdString);
-  const response = await waitForDankMemer(10000);
+// Filter utility buttons (null labels, warnings, refresh)
+function gameButtons(msg) {
+  return getAllButtons(msg).filter(b =>
+    !b.disabled && b.label && b.label !== 'null' &&
+    !(b.customId || b.custom_id || '').includes('warning') &&
+    !(b.customId || b.custom_id || '').includes('refresh')
+  );
+}
 
+async function commonChecks(response, cmdName) {
   if (!response) {
     LOG.warn(`[${cmdName}] No response`);
-    return { result: 'no response', coins: 0 };
+    return { skip: true, ret: { result: 'no response', coins: 0 } };
   }
-
   if (isHoldTight(response)) {
     const reason = getHoldTightReason(response);
-    LOG.warn(`[${cmdName}] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    LOG.warn(`[${cmdName}] Hold Tight${reason ? ` (/${reason})` : ''} — waiting 30s`);
     await sleep(30000);
-    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+    return { skip: true, ret: { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason } };
+  }
+  const text = getFullText(response);
+  const minBet = checkMinBet(text);
+  if (minBet !== 0) {
+    const val = minBet > 0 ? minBet : 0;
+    LOG.warn(`[${cmdName}] Min bet: ⏣ ${val > 0 ? val.toLocaleString() : '?'}`);
+    return { skip: true, ret: { result: `min bet ${val}`, coins: 0, newMinBet: val > 0 ? val : undefined } };
   }
+  return { skip: false };
+}
 
-  // Check for min bet error
-  const initText = getFullText(response);
-  const initLower = initText.toLowerCase();
-  if (initLower.includes("can't bet less than") || initLower.includes('cannot bet less than') || initLower.includes('minimum bet')) {
-    const betMatch = initText.match(/less than\s*\*?\*?[⏣o]?\s*([\d,]+)/i) || initText.match(/(\d[\d,]+)/);
-    if (betMatch) {
-      const minBet = parseInt(betMatch[1].replace(/,/g, ''));
-      if (minBet > 0) return { result: `min bet ${minBet}`, coins: 0, newMinBet: minBet };
-    }
-    return { result: 'min bet error', coins: 0 };
+/**
+ * Cointoss — CV2 format. Fetch raw components, pick Heads/Tails randomly.
+ */
+async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
+  const cmd = `pls cointoss ${betAmount}`;
+  LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
+  await channel.send(cmd);
+  let response = await waitForDankMemer(10000);
+
+  await ensureCV2(response);
+  const chk = await commonChecks(response, 'cointoss');
+  if (chk.skip) return chk.ret;
+
+  logMsg(response, 'cointoss');
+  const btns = gameButtons(response).filter(b =>
+    !(b.customId || b.custom_id || '').includes('bet')
+  );
+
+  if (btns.length > 0) {
+    const choice = Math.random() < 0.5 ? 'head' : 'tail';
+    const btn = btns.find(b => (b.label || '').toLowerCase().includes(choice)) || btns[0];
+    LOG.info(`[cointoss] Picking "${btn.label}"`);
+    await humanDelay(200, 500);
+    try {
+      const followUp = await safeClickButton(response, btn);
+      if (followUp) {
+        await ensureCV2(followUp);
+        return parseResult(getFullText(followUp), 'cointoss');
+      }
+      // CV2 click returns null — wait for message update, clear cache, refetch
+      await sleep(2500);
+      response._cv2 = null;
+      response._cv2text = null;
+      response._cv2buttons = null;
+      await ensureCV2(response);
+      return parseResult(getFullText(response), 'cointoss');
+    } catch (e) { LOG.error(`[cointoss] Click error: ${e.message}`); }
   }
 
-  logMsg(response, cmdName);
-  const text = getFullText(response);
+  return parseResult(getFullText(response), 'cointoss');
+}
 
-  // For cointoss/gambles with buttons: click a random non-disabled button
-  const buttons = getAllButtons(response);
-  if (buttons.length > 0) {
-    const clickable = buttons.filter(b => !b.disabled);
-    if (clickable.length > 0) {
-      const btn = clickable[Math.floor(Math.random() * clickable.length)];
-      LOG.info(`[${cmdName}] Clicking "${btn.label || '?'}"`);
-      await humanDelay(50, 200);
-      try {
-        const followUp = await safeClickButton(response, btn);
-        if (followUp) {
-          logMsg(followUp, `${cmdName}-result`);
-          const fText = getFullText(followUp);
-          return parseGambleResult(fText, cmdName);
-        }
-      } catch (e) { LOG.error(`[${cmdName}] Click error: ${e.message}`); }
-    }
+/**
+ * Roulette — embed format. Always pick Red (best even-money odds ~48.6%).
+ * Sometimes auto-bets if color is in command, sometimes shows buttons.
+ */
+async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
+  const cmd = `pls roulette ${betAmount} red`;
+  LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
+  await channel.send(cmd);
+  let response = await waitForDankMemer(10000);
+
+  const chk = await commonChecks(response, 'roulette');
+  if (chk.skip) return chk.ret;
+
+  logMsg(response, 'roulette');
+
+  // Check if buttons appeared (manual pick needed)
+  const btns = gameButtons(response).filter(b =>
+    !(b.customId || b.custom_id || '').includes('bet')
+  );
+  const redBtn = btns.find(b => (b.label || '').toLowerCase() === 'red');
+  if (redBtn) {
+    LOG.info(`[roulette] Picking "Red"`);
+    await humanDelay(200, 500);
+    try {
+      const followUp = await safeClickButton(response, redBtn);
+      if (followUp) {
+        response = followUp;
+        logMsg(response, 'roulette-after-pick');
+      }
+    } catch (e) { LOG.error(`[roulette] Click error: ${e.message}`); }
   }
 
-  return parseGambleResult(text, cmdName);
+  // Wait for spin animation to complete
+  let text = getFullText(response);
+  if (text.toLowerCase().includes('spinning') || text.toLowerCase().includes('rolling') || text.toLowerCase().includes('pick a color')) {
+    await sleep(3500);
+    try {
+      const final = await channel.messages.fetch(response.id);
+      if (final) text = getFullText(final);
+    } catch {}
+  }
+
+  return parseResult(text, 'roulette');
 }
 
 /**
- * Cointoss: send "pls cointoss <bet>", then click Heads or Tails randomly.
+ * Slots — embed format. Auto-spins, no button needed. Wait for animation.
  */
-async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'cointoss', cmdString: `pls cointoss ${betAmount}` });
-}
+async function runSlots({ channel, waitForDankMemer, betAmount = 10000 }) {
+  const cmd = `pls slots ${betAmount}`;
+  LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
+  await channel.send(cmd);
+  let response = await waitForDankMemer(10000);
 
-async function runRoulette({ channel, waitForDankMemer, betAmount = 5000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'roulette', cmdString: `pls roulette ${betAmount} red` });
-}
+  const chk = await commonChecks(response, 'slots');
+  if (chk.skip) return chk.ret;
+
+  logMsg(response, 'slots');
+  const text = getFullText(response);
+
+  // Slots auto-spins — if still animating, wait and refetch
+  if (text.toLowerCase().includes('spinning')) {
+    await sleep(3500);
+    try {
+      const final = await channel.messages.fetch(response.id);
+      if (final) return parseResult(getFullText(final), 'slots');
+    } catch {}
+  }
 
-async function runSlots({ channel, waitForDankMemer, betAmount = 5000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'slots', cmdString: `pls slots ${betAmount}` });
+  return parseResult(text, 'slots');
 }
 
-async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 5000 }) {
-  return runGamble({ channel, waitForDankMemer, cmdName: 'snakeeyes', cmdString: `pls snakeeyes ${betAmount}` });
+/**
+ * Snakeeyes — embed format. Auto-rolls, no button needed. Wait for animation.
+ */
+async function runSnakeeyes({ channel, waitForDankMemer, betAmount = 10000 }) {
+  const cmd = `pls snakeeyes ${betAmount}`;
+  LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
+  await channel.send(cmd);
+  let response = await waitForDankMemer(10000);
+
+  const chk = await commonChecks(response, 'snakeeyes');
+  if (chk.skip) return chk.ret;
+
+  logMsg(response, 'snakeeyes');
+  const text = getFullText(response);
+
+  // Snakeeyes auto-rolls — if still animating, wait and refetch
+  if (text.toLowerCase().includes('rolling')) {
+    await sleep(3500);
+    try {
+      const final = await channel.messages.fetch(response.id);
+      if (final) return parseResult(getFullText(final), 'snakeeyes');
+    } catch {}
+  }
+
+  return parseResult(text, 'snakeeyes');
 }
 
-module.exports = { runGamble, runCointoss, runRoulette, runSlots, runSnakeeyes };
+module.exports = { runCointoss, runRoulette, runSlots, runSnakeeyes };

package/lib/commands/generic.js

@@ -7,6 +7,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, getAllSelectMenus,
   safeClickButton, logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay, needsItem,
+  isCV2, ensureCV2,
 } = require('./utils');
 const { buyItem } = require('./shop');
 
@@ -23,7 +24,7 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
   LOG.cmd(`${c.white}${c.bold}${cmdString}${c.reset}`);
 
   await channel.send(cmdString);
-  const response = await waitForDankMemer(10000);
+  let response = await waitForDankMemer(10000);
 
   if (!response) {
     LOG.warn(`[${cmdName}] No response`);
@@ -37,6 +38,7 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
 
+  if (isCV2(response)) await ensureCV2(response);
   logMsg(response, cmdName);
   const text = getFullText(response);
   const coins = parseCoins(text);
@@ -109,12 +111,14 @@ async function runGeneric({ channel, waitForDankMemer, cmdString, cmdName, clien
     // Find row index of first select menu
     let menuRowIdx = -1;
     for (let i = 0; i < (response.components || []).length; i++) {
-      for (const comp of response.components[i].components || []) {
+      const row = response.components[i];
+      if (!row) continue;
+      for (const comp of row.components || []) {
         if (comp.type === 'STRING_SELECT' || comp.type === 3) { menuRowIdx = i; break; }
       }
       if (menuRowIdx >= 0) break;
     }
-    const menu = menuRowIdx >= 0 ? response.components[menuRowIdx].components[0] : null;
+    const menu = menuRowIdx >= 0 ? response.components?.[menuRowIdx]?.components?.[0] : null;
     const options = menu?.options || [];
     if (options.length > 0 && menuRowIdx >= 0) {
       const opt = options[Math.floor(Math.random() * options.length)];

package/lib/commands/highlow.js

@@ -27,9 +27,9 @@ function parseHintNumber(text) {
 }
 
 function parseNetCoins(text) {
-  const netMatch = text.match(/Net:\s*[⏣o]\s*(-?[\d,]+)/i);
+  const netMatch = text.match(/Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i);
   if (netMatch) return parseInt(netMatch[1].replace(/,/g, ''));
-  const winMatch = text.match(/Winnings:\s*[⏣o]\s*([\d,]+)/i);
+  const winMatch = text.match(/Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i);
   if (winMatch) return parseInt(winMatch[1].replace(/,/g, ''));
   return 0;
 }

package/lib/commands/index.js

@@ -16,13 +16,14 @@ const { runScratch } = require('./scratch');
 const { runBlackjack } = require('./blackjack');
 const { runTrivia, triviaDB } = require('./trivia');
 const { runWorkShift } = require('./work');
-const { runCointoss, runRoulette, runSlots, runSnakeeyes, runGamble } = require('./gamble');
+const { runCointoss, runRoulette, runSlots, runSnakeeyes } = require('./gamble');
 const { runDeposit } = require('./deposit');
 const { runGeneric, runAlert } = require('./generic');
 const { runStream } = require('./stream');
 const { runDrops } = require('./drops');
 const { buyItem, ITEM_COSTS } = require('./shop');
 const { getPlayerLevel, meetsLevelRequirement } = require('./profile');
+const { runInventory, fetchItemValues, enrichItems, getCachedInventory, getAllInventories, updateInventoryItem, deleteInventoryItem } = require('./inventory');
 
 module.exports = {
   // Individual commands
@@ -43,7 +44,6 @@ module.exports = {
   runRoulette,
   runSlots,
   runSnakeeyes,
-  runGamble,
   runDeposit,
   runGeneric,
   runAlert,
@@ -51,6 +51,15 @@ module.exports = {
   runDrops,
   buyItem,
 
+  // Inventory
+  runInventory,
+  fetchItemValues,
+  enrichItems,
+  getCachedInventory,
+  getAllInventories,
+  updateInventoryItem,
+  deleteInventoryItem,
+
   // Profile / Level
   getPlayerLevel,
   meetsLevelRequirement,