dankgrinder 3.0.0 → 4.1.0

package/lib/commands/blackjack.js

@@ -0,0 +1,85 @@
+/**
+ * Blackjack command handler.
+ * Send "pls bj <bet>", play hit/stand based on card total.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {number} [opts.betAmount=1000]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runBlackjack({ channel, waitForDankMemer, betAmount = 1000 }) {
+  const cmd = `pls bj ${betAmount}`;
+  LOG.cmd(`${c.white}${c.bold}${cmd}${c.reset}`);
+
+  await channel.send(cmd);
+  let current = await waitForDankMemer(10000);
+
+  if (!current) {
+    LOG.warn('[bj] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(current)) {
+    const reason = getHoldTightReason(current);
+    LOG.warn(`[bj] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(current, 'bj');
+
+  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;
+
+    // Parse player total
+    const totalMatch = text.match(/total[:\s]*\**(\d+)\**/i) || text.match(/value[:\s]*\**(\d+)\**/i);
+    const playerTotal = totalMatch ? parseInt(totalMatch[1]) : 0;
+
+    let targetBtn;
+    if (playerTotal >= 17 || playerTotal === 0) {
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('stand')) || buttons[1];
+    } else {
+      targetBtn = buttons.find(b => (b.label || '').toLowerCase().includes('hit')) || buttons[0];
+    }
+
+    if (!targetBtn || targetBtn.disabled) break;
+
+    LOG.info(`[bj] Total: ${playerTotal} → ${targetBtn.label}`);
+    await humanDelay(500, 1200);
+
+    try {
+      const followUp = await safeClickButton(current, targetBtn);
+      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; }
+  }
+
+  const finalText = getFullText(current);
+  const coins = parseCoins(finalText);
+  const lower = finalText.toLowerCase();
+
+  if (coins > 0) {
+    LOG.coin(`[bj] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `bj → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+  if (lower.includes('won')) return { result: `bj → ${c.green}won${c.reset}`, coins: 0 };
+  if (lower.includes('lost') || lower.includes('bust')) return { result: `bj → ${c.red}lost${c.reset}`, coins: 0 };
+  return { result: 'bj done', coins: 0 };
+}
+
+module.exports = { runBlackjack };

package/lib/commands/crime.js

@@ -0,0 +1,94 @@
+/**
+ * Crime command handler.
+ * Send "pls crime", pick a safe option, click it, parse coins.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, getAllButtons, safeClickButton,
+  logMsg, isHoldTight, getHoldTightReason, sleep, humanDelay,
+} = require('./utils');
+
+const SAFE_CRIME_OPTIONS = [
+  'tax evasion', 'fraud', 'cybercrime', 'hacking', 'identity theft',
+  'money laundering', 'tax fraud', 'insurance fraud', 'scam',
+];
+
+function pickSafeButton(buttons, customSafe) {
+  if (!buttons || buttons.length === 0) return null;
+  if (customSafe && customSafe.length > 0) {
+    for (const btn of buttons) {
+      const label = (btn.label || '').toLowerCase();
+      if (customSafe.some(s => label.includes(s.toLowerCase()))) return btn;
+    }
+  }
+  for (const btn of buttons) {
+    const label = (btn.label || '').toLowerCase();
+    if (SAFE_CRIME_OPTIONS.some(s => label.includes(s))) return btn;
+  }
+  const clickable = buttons.filter(b => !b.disabled);
+  return clickable.length > 0 ? clickable[Math.floor(Math.random() * clickable.length)] : null;
+}
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {string[]} [opts.safeAnswers]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runCrime({ channel, waitForDankMemer, safeAnswers }) {
+  LOG.cmd(`${c.white}${c.bold}pls crime${c.reset}`);
+
+  await channel.send('pls crime');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[crime] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[crime] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'crime');
+  const buttons = getAllButtons(response);
+
+  if (buttons.length === 0) {
+    const text = getFullText(response);
+    LOG.info(`[crime] No buttons: ${text.substring(0, 80)}`);
+    return { result: text.substring(0, 60), coins: 0 };
+  }
+
+  const btn = pickSafeButton(buttons, safeAnswers);
+  if (!btn) {
+    LOG.warn('[crime] No safe button found');
+    return { result: 'no safe option', coins: 0 };
+  }
+
+  LOG.info(`[crime] Picking: "${btn.label}"`);
+  await humanDelay();
+
+  try {
+    const followUp = await safeClickButton(response, btn);
+    if (followUp) {
+      logMsg(followUp, 'crime-result');
+      const text = getFullText(followUp);
+      const coins = parseCoins(text);
+      if (coins > 0) {
+        LOG.coin(`[crime] ${btn.label} → ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+        return { result: `${btn.label} → +⏣ ${coins.toLocaleString()}`, coins };
+      }
+      return { result: `${btn.label} → done`, coins: 0 };
+    }
+    return { result: `clicked: ${btn.label}`, coins: 0 };
+  } catch (e) {
+    LOG.error(`[crime] Click error: ${e.message}`);
+    return { result: `error: ${e.message}`, coins: 0 };
+  }
+}
+
+module.exports = { runCrime, SAFE_CRIME_OPTIONS };

package/lib/commands/deposit.js

@@ -0,0 +1,46 @@
+/**
+ * Deposit command handler.
+ * Send "pls dep max" to deposit all wallet coins to bank.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep,
+} = require('./utils');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runDeposit({ channel, waitForDankMemer }) {
+  LOG.cmd(`${c.white}${c.bold}pls dep max${c.reset}`);
+
+  await channel.send('pls dep max');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[deposit] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[deposit] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'deposit');
+  const text = getFullText(response);
+  const coins = parseCoins(text);
+
+  if (text.toLowerCase().includes('deposited')) {
+    LOG.success(`[deposit] Deposited ${c.green}⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `deposited ⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: text.substring(0, 60) || 'deposit done', coins: 0 };
+}
+
+module.exports = { runDeposit };

package/lib/commands/dig.js

@@ -0,0 +1,82 @@
+/**
+ * Dig command handler.
+ * Send "pls dig", detect if shovel is missing, auto-buy if needed.
+ */
+
+const {
+  LOG, c, getFullText, parseCoins, logMsg, isHoldTight, getHoldTightReason, sleep, needsItem,
+} = require('./utils');
+const { buyItem } = require('./shop');
+
+/**
+ * @param {object} opts
+ * @param {object} opts.channel
+ * @param {function} opts.waitForDankMemer
+ * @param {object} [opts.client]
+ * @returns {Promise<{result: string, coins: number}>}
+ */
+async function runDig({ channel, waitForDankMemer, client }) {
+  LOG.cmd(`${c.white}${c.bold}pls dig${c.reset}`);
+
+  await channel.send('pls dig');
+  const response = await waitForDankMemer(10000);
+
+  if (!response) {
+    LOG.warn('[dig] No response');
+    return { result: 'no response', coins: 0 };
+  }
+
+  if (isHoldTight(response)) {
+    const reason = getHoldTightReason(response);
+    LOG.warn(`[dig] Hold Tight${reason ? ` (reason: /${reason})` : ''} — waiting 30s`);
+    await sleep(30000);
+    return { result: `hold tight (${reason || 'unknown'})`, coins: 0, holdTightReason: reason };
+  }
+
+  logMsg(response, 'dig');
+  const text = getFullText(response);
+  const textLower = text.toLowerCase();
+
+  // Check if we need a shovel
+  if (textLower.includes("don't have") && textLower.includes('shovel') ||
+      textLower.includes('need') && textLower.includes('shovel')) {
+    LOG.warn('[dig] No shovel! Attempting to buy...');
+
+    const bought = await buyItem({
+      channel, waitForDankMemer, client,
+      itemName: 'Shovel',
+      quantity: 3,
+    });
+
+    if (bought) {
+      LOG.success('[dig] Shovel purchased! Re-running dig...');
+      // Drain any stale shop messages before retrying
+      while (await waitForDankMemer(1500)) { /* drain */ }
+      await sleep(1000);
+
+      await channel.send('pls dig');
+      const r2 = await waitForDankMemer(10000);
+      if (r2) {
+        logMsg(r2, 'dig-retry');
+        const t2 = getFullText(r2);
+        const coins = parseCoins(t2);
+        if (coins > 0) {
+          LOG.coin(`[dig] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+          return { result: `dig → +⏣ ${coins.toLocaleString()}`, coins };
+        }
+        return { result: t2.substring(0, 60), coins: 0 };
+      }
+    }
+    return { result: 'need shovel (buy failed)', coins: 0 };
+  }
+
+  const coins = parseCoins(text);
+  if (coins > 0) {
+    LOG.coin(`[dig] ${c.green}+⏣ ${coins.toLocaleString()}${c.reset}`);
+    return { result: `dig → +⏣ ${coins.toLocaleString()}`, coins };
+  }
+
+  return { result: text.substring(0, 60) || 'done', coins: 0 };
+}
+
+module.exports = { runDig };