blockmine 1.23.3 → 1.24.0

package/backend/src/core/nodes/container/deposit.js

@@ -0,0 +1,88 @@
+/**
+ * container:deposit - Положить предмет в контейнер
+ *
+ * Executor для action ноды с exec пинами.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+  const container = context.openContainer;
+
+  if (!bot || !container) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:deposited`, 0);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  const itemName = await resolvePinValue(node, 'itemName', node.data?.itemName);
+  const count = await resolvePinValue(node, 'count', node.data?.count);
+
+  if (!itemName) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:deposited`, 0);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+
+    // Ищем предметы в инвентаре бота
+    const items = bot.inventory.items().filter(item =>
+      item.name.toLowerCase().includes(searchName) ||
+      item.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (items.length === 0) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:deposited`, 0);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    let deposited = 0;
+    let remaining = count || Infinity;
+
+    for (const item of items) {
+      if (remaining <= 0) break;
+
+      const toDeposit = Math.min(item.count, remaining);
+
+      try {
+        await container.deposit(item.type, item.metadata, toDeposit);
+        deposited += toDeposit;
+        remaining -= toDeposit;
+      } catch (e) {
+        break;
+      }
+    }
+
+    memo.set(`${node.id}:deposited`, deposited);
+    memo.set(`${node.id}:success`, deposited > 0);
+
+    await traverse(node, deposited > 0 ? 'exec' : 'exec_failed');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:deposited`, 0);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+/**
+ * Evaluator для data пинов (success, deposited)
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'deposited') {
+    return memo.get(`${node.id}:deposited`) ?? 0;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/container/deposit_all.js

@@ -0,0 +1,71 @@
+/**
+ * container:deposit_all - Положить все предметы в контейнер
+ *
+ * Executor для action ноды с exec пинами.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+  const container = context.openContainer;
+
+  if (!bot || !container) {
+    memo.set(`${node.id}:deposited`, 0);
+    await traverse(node, 'exec');
+    return;
+  }
+
+  const itemName = await resolvePinValue(node, 'itemName', node.data?.itemName);
+  const keepOne = await resolvePinValue(node, 'keepOne', node.data?.keepOne);
+
+  try {
+    const searchName = itemName ? itemName.toLowerCase().replace('minecraft:', '') : null;
+
+    // Получаем предметы из инвентаря
+    let items = bot.inventory.items();
+
+    // Фильтруем по имени если указано
+    if (searchName) {
+      items = items.filter(item =>
+        item.name.toLowerCase().includes(searchName) ||
+        item.displayName?.toLowerCase().includes(searchName)
+      );
+    }
+
+    let deposited = 0;
+
+    for (const item of items) {
+      const toDeposit = keepOne ? Math.max(0, item.count - 1) : item.count;
+
+      if (toDeposit <= 0) continue;
+
+      try {
+        await container.deposit(item.type, item.metadata, toDeposit);
+        deposited += toDeposit;
+      } catch (e) {
+        break;
+      }
+    }
+
+    memo.set(`${node.id}:deposited`, deposited);
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:deposited`, 0);
+    await traverse(node, 'exec');
+  }
+}
+
+/**
+ * Evaluator для data пинов (deposited)
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'deposited') {
+    return memo.get(`${node.id}:deposited`) ?? 0;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/container/find_item.js

@@ -0,0 +1,77 @@
+/**
+ * container:find_item - Найти предмет в контейнере
+ *
+ * Data нода (без exec пинов) - использует только evaluator.
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { resolvePinValue } = helpers;
+  const container = context.openContainer;
+  const itemName = await resolvePinValue(node, 'itemName', node.data?.itemName);
+
+  if (!container || !itemName) {
+    if (pinId === 'item') return null;
+    if (pinId === 'slot') return -1;
+    if (pinId === 'count') return 0;
+    if (pinId === 'found') return false;
+    return null;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+
+    // Получаем предметы из контейнера
+    const containerItems = container.containerItems ? container.containerItems() : [];
+
+    // Ищем предмет
+    let foundItem = null;
+    let foundSlot = -1;
+    let totalCount = 0;
+
+    containerItems.forEach((item, index) => {
+      if (!item) return;
+
+      const matches = item.name.toLowerCase().includes(searchName) ||
+                      item.displayName?.toLowerCase().includes(searchName);
+
+      if (matches) {
+        if (!foundItem) {
+          foundItem = item;
+          foundSlot = index;
+        }
+        totalCount += item.count;
+      }
+    });
+
+    if (pinId === 'item') {
+      if (!foundItem) return null;
+
+      // Извлекаем прочность из NBT
+      const damage = foundItem.nbt?.value?.Damage?.value ?? 0;
+      const maxDurability = foundItem.maxDurability ?? null;
+      const durability = maxDurability ? maxDurability - damage : null;
+
+      return {
+        name: foundItem.name,
+        displayName: foundItem.displayName,
+        count: foundItem.count,
+        slot: foundSlot,
+        durability,
+        maxDurability,
+        damage
+      };
+    }
+
+    if (pinId === 'slot') return foundSlot;
+    if (pinId === 'count') return totalCount;
+    if (pinId === 'found') return foundItem !== null;
+  } catch (error) {
+    if (pinId === 'item') return null;
+    if (pinId === 'slot') return -1;
+    if (pinId === 'count') return 0;
+    if (pinId === 'found') return false;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/container/get_items.js

@@ -0,0 +1,51 @@
+/**
+ * container:get_items - Получить содержимое контейнера
+ *
+ * Data нода (без exec пинов) - использует только evaluator.
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { resolvePinValue } = helpers;
+  const container = (await resolvePinValue(node, 'container', null)) || context.openContainer;
+
+  if (!container) {
+    if (pinId === 'items') return [];
+    if (pinId === 'count') return 0;
+    return null;
+  }
+
+  try {
+    const items = container.containerItems ? container.containerItems() : [];
+
+    const nonEmptyItems = items.filter(item => item !== null);
+
+    if (pinId === 'items') {
+      return nonEmptyItems.map(item => {
+        const damage = item.nbt?.value?.Damage?.value ?? 0;
+        const maxDurability = item.maxDurability ?? null;
+        const durability = maxDurability ? maxDurability - damage : null;
+
+        return {
+          name: item.name,
+          displayName: item.displayName,
+          count: item.count,
+          slot: item.slot,
+          stackSize: item.stackSize,
+          durability,
+          maxDurability,
+          damage
+        };
+      });
+    }
+
+    if (pinId === 'count') {
+      return nonEmptyItems.length;
+    }
+  } catch (error) {
+    if (pinId === 'items') return [];
+    if (pinId === 'count') return 0;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/container/open.js

@@ -0,0 +1,111 @@
+const Vec3 = require('vec3');
+
+/**
+ * container:open - Открыть контейнер по координатам
+ *
+ * Executor для action ноды с exec пинами.
+ * Использует helpers.traverse для перехода к следующему exec выходу.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+
+  if (!bot) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:container`, null);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  const x = await resolvePinValue(node, 'x', node.data?.x);
+  const y = await resolvePinValue(node, 'y', node.data?.y);
+  const z = await resolvePinValue(node, 'z', node.data?.z);
+
+  const targetX = Number(x ?? 0);
+  const targetY = Number(y ?? 64);
+  const targetZ = Number(z ?? 0);
+
+  try {
+    const block = bot.blockAt(new Vec3(targetX, targetY, targetZ));
+
+    if (!block) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:container`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const containerTypes = [
+      'chest', 'trapped_chest', 'barrel', 'shulker_box',
+      'hopper', 'dropper', 'dispenser', 'furnace',
+      'blast_furnace', 'smoker', 'brewing_stand'
+    ];
+    const isContainer = containerTypes.some(type => block.name.includes(type));
+
+    if (!isContainer) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:container`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const distance = bot.entity.position.distanceTo(block.position);
+
+    if (distance > 4) {
+      if (bot.pathfinder) {
+        const { goals } = require('mineflayer-pathfinder');
+        const goal = new goals.GoalNear(block.position.x, block.position.y, block.position.z, 2);
+        await bot.pathfinder.goto(goal);
+      } else {
+        memo.set(`${node.id}:success`, false);
+        memo.set(`${node.id}:container`, null);
+        await traverse(node, 'exec_failed');
+        return;
+      }
+    }
+
+    if (bot.currentWindow) {
+      bot.closeWindow(bot.currentWindow);
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    const blockCenter = block.position.offset(0.5, 0.5, 0.5);
+    await bot.lookAt(blockCenter);
+    await new Promise(r => setTimeout(r, 100));
+
+    const container = await bot.openContainer(block);
+
+    if (!container) {
+      throw new Error('Container is null');
+    }
+
+    context.openContainer = container;
+
+    memo.set(`${node.id}:success`, true);
+    memo.set(`${node.id}:container`, container);
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:container`, null);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+/**
+ * Evaluator для data пинов (success, container)
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'container') {
+    return memo.get(`${node.id}:container`) ?? context.openContainer ?? null;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/container/withdraw.js

@@ -0,0 +1,91 @@
+/**
+ * container:withdraw - Забрать предмет из контейнера
+ *
+ * Executor для action ноды с exec пинами.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+  const container = context.openContainer;
+
+  if (!bot || !container) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:withdrawn`, 0);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  const itemName = await resolvePinValue(node, 'itemName', node.data?.itemName);
+  const count = await resolvePinValue(node, 'count', node.data?.count);
+
+  if (!itemName) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:withdrawn`, 0);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+
+    // Ищем предметы в контейнере
+    const containerItems = container.containerItems ? container.containerItems() : [];
+    const items = containerItems.filter(item =>
+      item && (
+        item.name.toLowerCase().includes(searchName) ||
+        item.displayName?.toLowerCase().includes(searchName)
+      )
+    );
+
+    if (items.length === 0) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:withdrawn`, 0);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    let withdrawn = 0;
+    let remaining = count || Infinity;
+
+    for (const item of items) {
+      if (remaining <= 0) break;
+
+      const toWithdraw = Math.min(item.count, remaining);
+
+      try {
+        await container.withdraw(item.type, item.metadata, toWithdraw);
+        withdrawn += toWithdraw;
+        remaining -= toWithdraw;
+      } catch (e) {
+        break;
+      }
+    }
+
+    memo.set(`${node.id}:withdrawn`, withdrawn);
+    memo.set(`${node.id}:success`, withdrawn > 0);
+
+    await traverse(node, withdrawn > 0 ? 'exec' : 'exec_failed');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:withdrawn`, 0);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+/**
+ * Evaluator для data пинов (success, withdrawn)
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'withdrawn') {
+    return memo.get(`${node.id}:withdrawn`) ?? 0;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/furnace/close.js

@@ -0,0 +1,24 @@
+/**
+ * furnace:close - Печка: закрыть
+ *
+ * Закрывает открытую печку.
+ */
+async function execute(node, context, helpers) {
+  const { traverse } = helpers;
+  const bot = context.bot;
+
+  try {
+    if (context.openFurnace) {
+      context.openFurnace.close();
+      context.openFurnace = null;
+    } else if (bot?.currentWindow) {
+      bot.closeWindow(bot.currentWindow);
+    }
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    await traverse(node, 'exec');
+  }
+}
+
+module.exports = { execute };

package/backend/src/core/nodes/furnace/get_status.js

@@ -0,0 +1,74 @@
+/**
+ * furnace:get_status - Печка: статус
+ *
+ * Получает текущий статус печки (топливо, прогресс, предметы в слотах).
+ * Data нода - использует только evaluator.
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const furnace = context.openFurnace;
+
+  if (!furnace) {
+    if (pinId === 'inputItem') return null;
+    if (pinId === 'fuelItem') return null;
+    if (pinId === 'outputItem') return null;
+    if (pinId === 'fuel') return 0;
+    if (pinId === 'progress') return 0;
+    if (pinId === 'isBurning') return false;
+    return null;
+  }
+
+  try {
+    if (pinId === 'inputItem') {
+      const item = furnace.inputItem();
+      if (!item) return null;
+      return {
+        name: item.name,
+        displayName: item.displayName,
+        count: item.count
+      };
+    }
+
+    if (pinId === 'fuelItem') {
+      const item = furnace.fuelItem();
+      if (!item) return null;
+      return {
+        name: item.name,
+        displayName: item.displayName,
+        count: item.count
+      };
+    }
+
+    if (pinId === 'outputItem') {
+      const item = furnace.outputItem();
+      if (!item) return null;
+      return {
+        name: item.name,
+        displayName: item.displayName,
+        count: item.count
+      };
+    }
+
+    if (pinId === 'fuel') {
+      return furnace.fuel ?? 0;
+    }
+
+    if (pinId === 'progress') {
+      return furnace.progress ?? 0;
+    }
+
+    if (pinId === 'isBurning') {
+      return (furnace.fuel ?? 0) > 0;
+    }
+  } catch (error) {
+    if (pinId === 'inputItem') return null;
+    if (pinId === 'fuelItem') return null;
+    if (pinId === 'outputItem') return null;
+    if (pinId === 'fuel') return 0;
+    if (pinId === 'progress') return 0;
+    if (pinId === 'isBurning') return false;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/furnace/open.js

@@ -0,0 +1,110 @@
+const Vec3 = require('vec3');
+
+/**
+ * furnace:open - Печка: открыть
+ *
+ * Открывает печку по координатам.
+ * Поддерживает: furnace, blast_furnace, smoker
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+
+  if (!bot) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:furnace`, null);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  const x = await resolvePinValue(node, 'x', node.data?.x);
+  const y = await resolvePinValue(node, 'y', node.data?.y);
+  const z = await resolvePinValue(node, 'z', node.data?.z);
+
+  const targetX = Number(x ?? 0);
+  const targetY = Number(y ?? 64);
+  const targetZ = Number(z ?? 0);
+
+  try {
+    const block = bot.blockAt(new Vec3(targetX, targetY, targetZ));
+
+    if (!block) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:furnace`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    // Проверяем что это печка
+    const furnaceTypes = ['furnace', 'blast_furnace', 'smoker'];
+    const isFurnace = furnaceTypes.some(type => block.name.includes(type));
+
+    if (!isFurnace) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:furnace`, null);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    // Проверяем расстояние
+    const distance = bot.entity.position.distanceTo(block.position);
+
+    if (distance > 4) {
+      if (bot.pathfinder) {
+        const { goals } = require('mineflayer-pathfinder');
+        const goal = new goals.GoalNear(block.position.x, block.position.y, block.position.z, 2);
+        await bot.pathfinder.goto(goal);
+      } else {
+        memo.set(`${node.id}:success`, false);
+        memo.set(`${node.id}:furnace`, null);
+        await traverse(node, 'exec_failed');
+        return;
+      }
+    }
+
+    // Закрываем текущее окно если есть
+    if (bot.currentWindow) {
+      bot.closeWindow(bot.currentWindow);
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    // Смотрим на печку
+    const blockCenter = block.position.offset(0.5, 0.5, 0.5);
+    await bot.lookAt(blockCenter);
+    await new Promise(r => setTimeout(r, 100));
+
+    // Открываем печку
+    const furnace = await bot.openFurnace(block);
+
+    if (!furnace) {
+      throw new Error('Furnace is null');
+    }
+
+    // Сохраняем печку в контексте
+    context.openFurnace = furnace;
+
+    memo.set(`${node.id}:success`, true);
+    memo.set(`${node.id}:furnace`, furnace);
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:furnace`, null);
+    await traverse(node, 'exec_failed');
+  }
+}
+
+async function evaluate(node, pinId, context, helpers) {
+  const { memo } = helpers;
+
+  if (pinId === 'success') {
+    return memo.get(`${node.id}:success`) ?? false;
+  }
+  if (pinId === 'furnace') {
+    return memo.get(`${node.id}:furnace`) ?? context.openFurnace ?? null;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };