dankgrinder 6.8.2 → 6.14.0

package/lib/commands/blackjack.js

@@ -1,6 +1,7 @@
 /**
  * Blackjack command handler.
- * Smart hit/stand: follows basic strategy based on player total and dealer upcard.
+ * Full basic strategy: hit, stand, double down, surrender.
+ * Fast button clicks with retry on failure.
  */
 
 const {
@@ -12,19 +13,16 @@ const RE_BACKTICK_SCORE = /`\s*(\d+)\s*`/;
 const RE_BJ_FACE_GLOBAL = /bjFace(\w+?):/g;
 const RE_BJ_FACE_SUFFIX = /[RB]$/;
 const RE_NET_LINE = /Net:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
-const RE_WINNINGS_LINE = /Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([\d,]+)/i;
+const RE_WINNINGS_LINE = /Winnings:\s*\*{0,2}\s*[⏣]\s*\*{0,2}([+-]?[\d,]+)/i;
 const RE_COMMA = /,/g;
 const COURT_RANKS = Object.freeze(['K', 'Q', 'J']);
 
 function parsePlayerTotal(msg) {
-  // Score is in embed field: ` 18 ` (backtick-wrapped number in Player field)
   const embeds = msg?.embeds || [];
-  for (let ei = 0; ei < embeds.length; ei++) {
-    const fields = embeds[ei].fields || [];
-    for (let fi = 0; fi < fields.length; fi++) {
-      const field = fields[fi];
-      if (field.name?.toLowerCase().includes('player')) {
-        const m = field.value.match(RE_BACKTICK_SCORE);
+  for (const e of embeds) {
+    for (const f of (e.fields || [])) {
+      if (f.name?.toLowerCase().includes('player')) {
+        const m = f.value.match(RE_BACKTICK_SCORE);
         if (m) return parseInt(m[1]);
       }
     }
@@ -35,21 +33,16 @@ function parsePlayerTotal(msg) {
 }
 
 function parseDealerUpcard(msg) {
-  // Dealer field: revealed total ` 18 ` or hidden ` ? `
-  // Upcard from emoji: bjFaceKB=K(10), bjFaceAR=A(11), bjFace7R=7
   const embeds = msg?.embeds || [];
-  for (let ei = 0; ei < embeds.length; ei++) {
-    const fields = embeds[ei].fields || [];
-    for (let fi = 0; fi < fields.length; fi++) {
-      const field = fields[fi];
-      if (field.name?.toLowerCase().includes('dealer')) {
-        const totalMatch = field.value.match(RE_BACKTICK_SCORE);
+  for (const e of embeds) {
+    for (const f of (e.fields || [])) {
+      if (f.name?.toLowerCase().includes('dealer')) {
+        const totalMatch = f.value.match(RE_BACKTICK_SCORE);
         if (totalMatch) return parseInt(totalMatch[1]);
-        const faces = [...field.value.matchAll(RE_BJ_FACE_GLOBAL)];
-        for (let fii = 0; fii < faces.length; fii++) {
-          const face = faces[fii][1];
-          if (face === 'Unknown') continue;
-          const v = face.replace(RE_BJ_FACE_SUFFIX, '');
+        const faces = [...f.value.matchAll(RE_BJ_FACE_GLOBAL)];
+        for (const face of faces) {
+          const v = face[1].replace(RE_BJ_FACE_SUFFIX, '');
+          if (v === 'Unknown') continue;
           if (v === 'A') return 11;
           if (COURT_RANKS.includes(v)) return 10;
           const n = parseInt(v);
@@ -70,18 +63,74 @@ function parseNetCoins(text) {
 }
 
 /**
- * Basic strategy decision.
- * - Always hit on ≤ 11
- * - Stand on ≥ 17
- * - 12-16: hit if dealer shows 7+ (strong upcard), else stand
+ * Full basic strategy decision.
+ * Returns: 'hit' | 'stand' | 'double' | 'surrender'
+ *
+ * Double Down (2x bet, get exactly 1 more card):
+ *   - Always double on 11
+ *   - Double on 10 if dealer shows 2-9
+ *   - Double on 9 if dealer shows 3-6
+ *
+ * Surrender:
+ *   - 16 vs dealer 9, 10, A
+ *   - 15 vs dealer 10
+ *
+ * Standard:
+ *   - Always hit ≤ 8
+ *   - Always stand ≥ 17
+ *   - 12: hit vs dealer 2-3 or 7+, stand vs 4-6
+ *   - 13-16: hit vs dealer 7+, stand vs 2-6
  */
-function shouldHit(playerTotal, dealerTotal) {
-  if (playerTotal <= 11) return true;
-  if (playerTotal >= 17) return false;
-  // 12-16: dealer has strong hand (7+), we need to risk hitting
-  if (dealerTotal >= 7) return true;
-  // Dealer has weak hand (2-6), likely to bust — stand and wait
-  return false;
+function decide(playerTotal, dealerUpcard, canDouble, canSurrender) {
+  // Double down opportunities (best +EV plays in blackjack)
+  if (canDouble) {
+    if (playerTotal === 11) return 'double';
+    if (playerTotal === 10 && dealerUpcard >= 2 && dealerUpcard <= 9) return 'double';
+    if (playerTotal === 9 && dealerUpcard >= 3 && dealerUpcard <= 6) return 'double';
+  }
+
+  // Surrender (cut losses on worst hands)
+  if (canSurrender) {
+    if (playerTotal === 16 && (dealerUpcard >= 9 || dealerUpcard === 11)) return 'surrender';
+    if (playerTotal === 15 && dealerUpcard === 10) return 'surrender';
+  }
+
+  // Always hit soft hands (≤ 8 can't bust)
+  if (playerTotal <= 8) return 'hit';
+
+  // Always stand on 17+
+  if (playerTotal >= 17) return 'stand';
+
+  // 12: tricky — hit vs 2, 3, 7+ ; stand vs 4-6
+  if (playerTotal === 12) {
+    return (dealerUpcard <= 3 || dealerUpcard >= 7) ? 'hit' : 'stand';
+  }
+
+  // 13-16: hit vs dealer 7+, stand vs 2-6
+  if (playerTotal >= 13 && playerTotal <= 16) {
+    return dealerUpcard >= 7 ? 'hit' : 'stand';
+  }
+
+  // 9-11 without double: hit
+  return 'hit';
+}
+
+// Fast button click with retry
+async function clickFast(msg, btn, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await sleep(50 + Math.random() * 100); // 50-150ms (fast)
+      const result = await safeClickButton(msg, btn);
+      if (result) return result;
+    } catch (e) {
+      if (attempt === retries) {
+        LOG.error(`[bj] Click failed after ${retries + 1} attempts: ${e.message}`);
+        return null;
+      }
+      await sleep(200);
+    }
+  }
+  return null;
 }
 
 async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
@@ -89,7 +138,7 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
   LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
 
   await channel.send(cmd);
-  let current = await waitForDankMemer(10000);
+  let current = await waitForDankMemer(12000);
 
   if (!current) {
     LOG.warn('[bj] No response');
@@ -100,7 +149,7 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
 
   if (isHoldTight(current)) {
     const reason = getHoldTightReason(current);
-    LOG.warn(`[bj] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    LOG.warn(`[bj] Hold Tight${reason ? ` (/${reason})` : ''} — waiting 30s`);
     await sleep(30000);
     return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
   }
@@ -110,34 +159,44 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
   const MAX_ROUNDS = 10;
   for (let i = 0; i < MAX_ROUNDS; i++) {
     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'));
+    const doubleBtn = buttons.find(b => !b.disabled && (b.label || '').toLowerCase().includes('double'));
+    const surrenderBtn = buttons.find(b => !b.disabled && (b.label || '').toLowerCase().includes('surrender'));
+
+    // No action buttons = game over
     if (!hitBtn && !standBtn) break;
 
     const playerTotal = parsePlayerTotal(current);
     const dealerUpcard = parseDealerUpcard(current);
+    const canDouble = !!doubleBtn;
+    const canSurrender = !!surrenderBtn;
+
+    const action = playerTotal === 0
+      ? 'stand' // can't parse score, play safe
+      : decide(playerTotal, dealerUpcard, canDouble, canSurrender);
 
     let targetBtn;
-    if (playerTotal === 0) {
-      targetBtn = standBtn || hitBtn;
-    } else if (shouldHit(playerTotal, dealerUpcard)) {
-      targetBtn = hitBtn || standBtn;
-    } else {
-      targetBtn = standBtn || hitBtn;
+    switch (action) {
+      case 'double':    targetBtn = doubleBtn || hitBtn; break;
+      case 'surrender': targetBtn = surrenderBtn || standBtn; break;
+      case 'hit':       targetBtn = hitBtn || standBtn; break;
+      case 'stand':     targetBtn = standBtn || hitBtn; break;
+      default:          targetBtn = standBtn || hitBtn;
     }
 
     if (!targetBtn) break;
 
-    LOG.info(`[bj] You:${playerTotal} Dealer:${dealerUpcard} → ${targetBtn.label}`);
-    await humanDelay(150, 400);
+    LOG.info(`[bj] You:${playerTotal} Dealer:${dealerUpcard} → ${action.toUpperCase()} (${targetBtn.label})`);
 
-    try {
-      const followUp = await safeClickButton(current, targetBtn);
-      if (followUp) {
-        current = followUp;
-        logMsg(current, `bj-round-${i}`);
-      } else break;
-    } catch { break; }
+    const followUp = await clickFast(current, targetBtn);
+    if (followUp) {
+      current = followUp;
+      logMsg(current, `bj-round-${i}`);
+    } else {
+      break;
+    }
   }
 
   const finalText = getFullText(current);
@@ -154,7 +213,7 @@ async function runBlackjack({ channel, waitForDankMemer, betAmount = 5000 }) {
   }
   if (lower.includes('won') || lower.includes('beat')) {
     const coins = parseCoins(finalText);
-    return { result: `bj → ${c.green}won${c.reset}`, coins };
+    return { result: `bj → won`, coins };
   }
   if (lower.includes('lost') || lower.includes('bust') || lower.includes('lower score')) {
     return { result: `bj → lost`, coins: 0, lost: betAmount };

package/lib/commands/crime.js

@@ -126,6 +126,14 @@ async function runCrime({ channel, waitForDankMemer, safeAnswers }) {
       const crimeKey = (btn.label || '').toLowerCase();
       const prev = crimeEarnings.get(crimeKey) || 0;
       crimeEarnings.set(crimeKey, prev + coins);
+
+      // Check for death
+      const textLower = text.toLowerCase();
+      if (textLower.includes('you died') || textLower.includes('lifesaver protected')) {
+        LOG.error(`[crime] DEATH DETECTED! Lifesaver may have been used.`);
+        return { result: `you died during crime`, coins: 0, died: true };
+      }
+
       if (coins > 0) {
         LOG.coin(`[crime] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
         return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };

package/lib/commands/fish.js

@@ -17,6 +17,7 @@
 const {
   LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
   logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+  isCV2, ensureCV2,
 } = require('./utils');
 const { downloadImage, extractImageUrl, findSafeCells } = require('./fishVision');
 
@@ -328,6 +329,9 @@ async function runFish({ channel, waitForDankMemer }) {
     return { result: `fish cooldown (${cd}s)`, coins: 0, nextCooldownSec: cd };
   }
 
+  // Ensure CV2 buttons are hydrated from raw gateway
+  if (isCV2(response)) await ensureCV2(response);
+
   // Re-fetch for hydrated CV2 components
   const msgId = response.id;
   const fresh = await refetchMsg(channel, msgId);
@@ -396,6 +400,9 @@ async function runFishLoop({ channel, waitForDankMemer, maxRounds = 50, onRound,
     return { totalRounds: 0, totalCaught: 0, totalMines: 0, results: [] };
   }
 
+  // Ensure CV2 buttons are hydrated
+  if (isCV2(response)) await ensureCV2(response);
+
   // Refetch for hydrated components
   let msgId = response.id;
   const fresh = await refetchMsg(channel, msgId);

package/lib/commands/gamble.js

@@ -2,11 +2,11 @@
  * Gambling command handlers.
  * Covers: cointoss (CV2), roulette, slots, snakeeyes
  *
- * Advanced techniques:
- *   Kelly Criterion  – optimal bet sizing based on observed win rate
- *   EMA              – exponential moving average for smoothed win probability
- *   AhoCorasick      – O(n) single-pass min-bet detection
- *   SlidingWindow    – time-based win/loss rate tracking
+ * All commands use:
+ *   - Fast button clicks (50-150ms) with retry (2 attempts)
+ *   - Kelly Criterion bet sizing
+ *   - EMA win-rate tracking
+ *   - Raw gateway data via rawLogger for CV2 buttons
  */
 
 const {
@@ -15,8 +15,7 @@ const {
 } = require('./utils');
 const { EMA, AhoCorasick, SlidingWindowCounter } = require('../structures');
 
-// ── Per-game EMA win-rate tracker ────────────────────────────
-// α=0.2 gives recent results ~5x more weight than old ones
+// ── Per-game EMA win-rate tracker ──
 const winRateEMA = {
   cointoss:  new EMA(0.2),
   roulette:  new EMA(0.2),
@@ -24,7 +23,6 @@ const winRateEMA = {
   snakeeyes: new EMA(0.2),
 };
 
-// ── Sliding window: wins in last 5 minutes per game ──────────
 const winWindow = {
   cointoss:  new SlidingWindowCounter(300000),
   roulette:  new SlidingWindowCounter(300000),
@@ -38,12 +36,6 @@ const totalWindow = {
   snakeeyes: new SlidingWindowCounter(300000),
 };
 
-// ── Kelly Criterion ──────────────────────────────────────────
-// f* = (bp - q) / b  where:
-//   b = net odds (payout ratio, e.g., 1.0 for even money)
-//   p = probability of winning (from EMA)
-//   q = 1 - p
-// Returns fraction of bankroll to bet (0 = don't bet, capped at 0.25)
 function kellyFraction(winProb, odds = 1.0) {
   if (winProb <= 0 || winProb >= 1) return 0.1;
   const q = 1 - winProb;
@@ -51,8 +43,7 @@ function kellyFraction(winProb, odds = 1.0) {
   return Math.max(0, Math.min(f, 0.25));
 }
 
-// ── Aho-Corasick for min-bet detection ───────────────────────
-// Single O(n) pass instead of 3 separate .includes() calls
+// ── Min-bet detection ──
 const minBetDetector = new AhoCorasick();
 minBetDetector.addPattern("can't bet less than", 'minbet');
 minBetDetector.addPattern('cannot bet less than', 'minbet');
@@ -126,14 +117,32 @@ async function commonChecks(response, cmdName) {
   return { skip: false };
 }
 
+// ── Fast click with retry ──
+async function clickFast(msg, btn, retries = 2) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      await sleep(50 + Math.random() * 100); // 50-150ms
+      const result = await safeClickButton(msg, btn);
+      if (result) return result;
+    } catch (e) {
+      if (attempt === retries) {
+        LOG.error(`Click failed after ${retries + 1} tries: ${e.message}`);
+        return null;
+      }
+      await sleep(200);
+    }
+  }
+  return null;
+}
+
 /**
- * Cointoss — CV2 format. Fetch raw components, pick Heads/Tails randomly.
+ * Cointoss — CV2 format. 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);
+  let response = await waitForDankMemer(12000);
 
   await ensureCV2(response);
   const chk = await commonChecks(response, 'cointoss');
@@ -148,28 +157,27 @@ async function runCointoss({ channel, waitForDankMemer, betAmount = 10000 }) {
     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(80, 200);
-    try {
-      const followUp = await safeClickButton(response, btn);
-      if (followUp) {
-        await ensureCV2(followUp);
-        return parseResult(getFullText(followUp), 'cointoss');
-      }
-      await sleep(1500);
-      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}`); }
+
+    const followUp = await clickFast(response, btn);
+    if (followUp) {
+      await ensureCV2(followUp);
+      return parseResult(getFullText(followUp), 'cointoss');
+    }
+    // Retry: re-fetch CV2 data from raw gateway
+    await sleep(1500);
+    response._cv2 = null;
+    response._cv2text = null;
+    response._cv2buttons = null;
+    await ensureCV2(response, true);
+    return parseResult(getFullText(response), 'cointoss');
   }
 
   return parseResult(getFullText(response), 'cointoss');
 }
 
 /**
- * Roulette — random color: red ~47.5%, black ~47.5%, green ~5% (rare).
- * Sometimes auto-bets if color is in command, sometimes shows buttons.
+ * Roulette — pick color, click button, wait for result.
+ * Strategy: ~47.5% red, ~47.5% black, ~5% green.
  */
 async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
   const roll = Math.random();
@@ -177,32 +185,31 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
   const cmd = `pls roulette ${betAmount} ${color}`;
   LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
   await channel.send(cmd);
-  let response = await waitForDankMemer(10000);
+  let response = await waitForDankMemer(12000);
 
   const chk = await commonChecks(response, 'roulette');
   if (chk.skip) return chk.ret;
 
   logMsg(response, 'roulette');
 
+  // Click the color button
   const btns = gameButtons(response).filter(b =>
     !(b.customId || b.custom_id || '').includes('bet')
   );
   const colorBtn = btns.find(b => (b.label || '').toLowerCase() === color);
   if (colorBtn) {
     LOG.info(`[roulette] Picking "${colorBtn.label}"`);
-    await humanDelay(100, 300);
-    try {
-      const followUp = await safeClickButton(response, colorBtn);
-      if (followUp) {
-        response = followUp;
-        logMsg(response, 'roulette-after-pick');
-      }
-    } catch (e) { LOG.error(`[roulette] Click error: ${e.message}`); }
+    const followUp = await clickFast(response, colorBtn);
+    if (followUp) {
+      response = followUp;
+      logMsg(response, 'roulette-after-pick');
+    }
   }
 
+  // Wait for result (roulette animates)
   let text = getFullText(response);
   if (text.toLowerCase().includes('spinning') || text.toLowerCase().includes('rolling') || text.toLowerCase().includes('pick a color')) {
-    await sleep(2000);
+    await sleep(2500);
     try {
       const final = await channel.messages.fetch(response.id);
       if (final) text = getFullText(final);
@@ -213,25 +220,30 @@ async function runRoulette({ channel, waitForDankMemer, betAmount = 10000 }) {
 }
 
 /**
- * Slots — embed format. Auto-spins, no button needed. Wait for animation.
+ * Slots — auto-spin, wait for animation to finish, parse result.
  */
 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);
+  let response = await waitForDankMemer(12000);
 
   const chk = await commonChecks(response, 'slots');
   if (chk.skip) return chk.ret;
 
   logMsg(response, 'slots');
-  const text = getFullText(response);
+  let text = getFullText(response);
 
+  // Slots animate — wait for the UPDATE with final result
   if (text.toLowerCase().includes('spinning')) {
-    await sleep(2000);
+    // Wait for message update event (animation takes ~2s)
+    await sleep(2500);
     try {
       const final = await channel.messages.fetch(response.id);
-      if (final) return parseResult(getFullText(final), 'slots');
+      if (final) {
+        text = getFullText(final);
+        logMsg(final, 'slots-final');
+      }
     } catch {}
   }
 
@@ -239,25 +251,29 @@ async function runSlots({ channel, waitForDankMemer, betAmount = 10000 }) {
 }
 
 /**
- * Snakeeyes — embed format. Auto-rolls, no button needed. Wait for animation.
+ * Snakeeyes — auto-roll, wait for animation to finish, parse result.
  */
 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);
+  let response = await waitForDankMemer(12000);
 
   const chk = await commonChecks(response, 'snakeeyes');
   if (chk.skip) return chk.ret;
 
   logMsg(response, 'snakeeyes');
-  const text = getFullText(response);
+  let text = getFullText(response);
 
+  // Snakeeyes animate — wait for final
   if (text.toLowerCase().includes('rolling')) {
-    await sleep(2000);
+    await sleep(2500);
     try {
       const final = await channel.messages.fetch(response.id);
-      if (final) return parseResult(getFullText(final), 'snakeeyes');
+      if (final) {
+        text = getFullText(final);
+        logMsg(final, 'snakeeyes-final');
+      }
     } catch {}
   }