blockmine 1.23.3 → 1.24.0

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

@@ -0,0 +1,64 @@
+/**
+ * furnace:put_fuel - Печка: положить топливо
+ *
+ * Кладёт топливо в слот топлива печки.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+  const furnace = context.openFurnace;
+
+  if (!bot || !furnace) {
+    memo.set(`${node.id}:success`, false);
+    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);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+
+    // Ищем предмет в инвентаре
+    const item = bot.inventory.items().find(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (!item) {
+      memo.set(`${node.id}:success`, false);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const amount = count ? Math.min(count, item.count) : item.count;
+
+    // Кладём в слот топлива
+    await furnace.putFuel(item.type, item.metadata, amount);
+
+    memo.set(`${node.id}:success`, true);
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    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;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

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

@@ -0,0 +1,64 @@
+/**
+ * furnace:put_input - Печка: положить для плавки
+ *
+ * Кладёт предмет в слот плавки печки.
+ */
+async function execute(node, context, helpers) {
+  const { resolvePinValue, traverse, memo } = helpers;
+  const bot = context.bot;
+  const furnace = context.openFurnace;
+
+  if (!bot || !furnace) {
+    memo.set(`${node.id}:success`, false);
+    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);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+
+    // Ищем предмет в инвентаре
+    const item = bot.inventory.items().find(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (!item) {
+      memo.set(`${node.id}:success`, false);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const amount = count ? Math.min(count, item.count) : item.count;
+
+    // Кладём в слот плавки
+    await furnace.putInput(item.type, item.metadata, amount);
+
+    memo.set(`${node.id}:success`, true);
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    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;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

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

@@ -0,0 +1,69 @@
+/**
+ * furnace:take_output - Печка: забрать результат
+ *
+ * Забирает готовый предмет из слота результата печки.
+ */
+async function execute(node, context, helpers) {
+  const { traverse, memo } = helpers;
+  const bot = context.bot;
+  const furnace = context.openFurnace;
+
+  if (!bot || !furnace) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:item`, null);
+    memo.set(`${node.id}:count`, 0);
+    await traverse(node, 'exec_failed');
+    return;
+  }
+
+  try {
+    // Проверяем есть ли что забирать
+    const outputItem = furnace.outputItem();
+
+    if (!outputItem) {
+      memo.set(`${node.id}:success`, false);
+      memo.set(`${node.id}:item`, null);
+      memo.set(`${node.id}:count`, 0);
+      await traverse(node, 'exec_failed');
+      return;
+    }
+
+    const countBefore = outputItem.count;
+
+    // Забираем результат
+    await furnace.takeOutput();
+
+    memo.set(`${node.id}:success`, true);
+    memo.set(`${node.id}:item`, {
+      name: outputItem.name,
+      displayName: outputItem.displayName,
+      count: countBefore
+    });
+    memo.set(`${node.id}:count`, countBefore);
+
+    await traverse(node, 'exec');
+  } catch (error) {
+    memo.set(`${node.id}:success`, false);
+    memo.set(`${node.id}:item`, null);
+    memo.set(`${node.id}:count`, 0);
+    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 === 'item') {
+    return memo.get(`${node.id}:item`) ?? null;
+  }
+  if (pinId === 'count') {
+    return memo.get(`${node.id}:count`) ?? 0;
+  }
+
+  return null;
+}
+
+module.exports = { execute, evaluate };

package/backend/src/core/nodes/inventory/count_item.js

@@ -0,0 +1,28 @@
+/**
+ * inventory:count_item - Подсчитать общее количество предмета в инвентаре
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const itemName = await helpers.resolvePinValue(node, 'itemName');
+
+  if (!bot?.inventory || !itemName) {
+    return 0;
+  }
+
+  // Ищем все предметы с таким именем и суммируем количество
+  const searchName = itemName.toLowerCase().replace('minecraft:', '');
+  const totalCount = bot.inventory.items()
+    .filter(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    )
+    .reduce((sum, item) => sum + item.count, 0);
+
+  if (pinId === 'count') {
+    return totalCount;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/drop.js

@@ -0,0 +1,65 @@
+/**
+ * inventory:drop - Выбросить предмет из инвентаря
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const itemName = await helpers.resolvePinValue(node, 'itemName');
+  const count = await helpers.resolvePinValue(node, 'count');
+  const dropAll = await helpers.resolvePinValue(node, 'dropAll');
+
+  if (pinId === 'exec') {
+    return true; // Exec output
+  }
+
+  if (!bot?.inventory || !itemName) {
+    if (pinId === 'dropped') return 0;
+    return null;
+  }
+
+  try {
+    // Ищем предмет(ы) в инвентаре
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+    const items = bot.inventory.items().filter(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (items.length === 0) {
+      if (pinId === 'dropped') return 0;
+      return null;
+    }
+
+    let totalDropped = 0;
+
+    if (dropAll) {
+      // Выбрасываем все такие предметы
+      for (const item of items) {
+        await bot.tossStack(item);
+        totalDropped += item.count;
+      }
+    } else {
+      // Выбрасываем указанное количество или один стак
+      const item = items[0];
+      const toDrop = count || item.count;
+
+      if (toDrop >= item.count) {
+        await bot.tossStack(item);
+        totalDropped = item.count;
+      } else {
+        await bot.toss(item.type, item.metadata, toDrop);
+        totalDropped = toDrop;
+      }
+    }
+
+    if (pinId === 'dropped') {
+      return totalDropped;
+    }
+  } catch (error) {
+    console.error('[inventory:drop] Error:', error.message);
+    if (pinId === 'dropped') return 0;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/equip.js

@@ -0,0 +1,45 @@
+/**
+ * inventory:equip - Экипировать предмет
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const itemName = await helpers.resolvePinValue(node, 'itemName');
+  const destination = (await helpers.resolvePinValue(node, 'destination')) || 'hand';
+
+  if (pinId === 'exec') {
+    return true; // Exec output
+  }
+
+  if (!bot?.inventory || !itemName) {
+    if (pinId === 'success') return false;
+    return null;
+  }
+
+  try {
+    // Ищем предмет в инвентаре
+    const searchName = itemName.toLowerCase().replace('minecraft:', '');
+    const item = bot.inventory.items().find(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    );
+
+    if (!item) {
+      if (pinId === 'success') return false;
+      return null;
+    }
+
+    // Экипируем предмет
+    await bot.equip(item, destination);
+
+    if (pinId === 'success') {
+      return true;
+    }
+  } catch (error) {
+    console.error('[inventory:equip] Error:', error.message);
+    if (pinId === 'success') return false;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

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

@@ -0,0 +1,55 @@
+/**
+ * inventory:find_item - Найти предмет в инвентаре по имени
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const itemName = await helpers.resolvePinValue(node, 'itemName');
+
+  if (!bot?.inventory || !itemName) {
+    if (pinId === 'item') return null;
+    if (pinId === 'found') return false;
+    if (pinId === 'slot') return -1;
+    return null;
+  }
+
+  // Ищем предмет (поддержка частичного совпадения)
+  const searchName = itemName.toLowerCase().replace('minecraft:', '');
+  const item = bot.inventory.items().find(i =>
+    i.name.toLowerCase().includes(searchName) ||
+    i.displayName?.toLowerCase().includes(searchName)
+  );
+
+  if (pinId === 'item') {
+    if (!item) return null;
+
+    // Извлекаем прочность из NBT
+    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,
+      type: item.type,
+      metadata: item.metadata,
+      nbt: item.nbt,
+      durability,        // Оставшаяся прочность
+      maxDurability,     // Максимальная прочность
+      damage             // Использованная прочность
+    };
+  }
+
+  if (pinId === 'found') {
+    return !!item;
+  }
+
+  if (pinId === 'slot') {
+    return item ? item.slot : -1;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/get_all.js

@@ -0,0 +1,45 @@
+/**
+ * inventory:get_all - Получить весь инвентарь бота
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+
+  if (!bot?.inventory) {
+    if (pinId === 'items') return [];
+    if (pinId === 'count') return 0;
+    return null;
+  }
+
+  // Получаем все непустые слоты
+  const items = bot.inventory.items().map(item => {
+    // Извлекаем прочность из NBT
+    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,
+      type: item.type,
+      metadata: item.metadata,
+      nbt: item.nbt,
+      durability,        // Оставшаяся прочность
+      maxDurability,     // Максимальная прочность
+      damage             // Использованная прочность
+    };
+  });
+
+  if (pinId === 'items') {
+    return items;
+  }
+
+  if (pinId === 'count') {
+    return items.length;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/get_held_item.js

@@ -0,0 +1,63 @@
+/**
+ * inventory:get_held_item - Получить предмет в руке бота
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const hand = (await helpers.resolvePinValue(node, 'hand')) || 'main';
+
+  if (!bot?.inventory) {
+    if (pinId === 'item') return null;
+    if (pinId === 'name') return '';
+    if (pinId === 'count') return 0;
+    if (pinId === 'hasItem') return false;
+    return null;
+  }
+
+  // Получаем предмет в руке
+  let item;
+  if (hand === 'off') {
+    // Офхенд слот (40 в Java Edition)
+    item = bot.inventory.slots[45]; // offhand slot
+  } else {
+    // Основная рука - текущий выбранный слот хотбара
+    item = bot.heldItem;
+  }
+
+  if (pinId === 'item') {
+    if (!item) return null;
+
+    // Извлекаем прочность из NBT
+    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,
+      type: item.type,
+      metadata: item.metadata,
+      nbt: item.nbt,
+      durability,        // Оставшаяся прочность
+      maxDurability,     // Максимальная прочность
+      damage             // Использованная прочность
+    };
+  }
+
+  if (pinId === 'name') {
+    return item?.name || '';
+  }
+
+  if (pinId === 'count') {
+    return item?.count || 0;
+  }
+
+  if (pinId === 'hasItem') {
+    return !!item;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/get_slot.js

@@ -0,0 +1,46 @@
+/**
+ * inventory:get_slot - Получить предмет в указанном слоте
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const slotNumber = await helpers.resolvePinValue(node, 'slotNumber');
+
+  if (!bot?.inventory || slotNumber === undefined || slotNumber === null) {
+    if (pinId === 'item') return null;
+    if (pinId === 'isEmpty') return true;
+    return null;
+  }
+
+  // Получаем предмет в слоте
+  const item = bot.inventory.slots[slotNumber];
+
+  if (pinId === 'item') {
+    if (!item) return null;
+
+    // Извлекаем прочность из NBT
+    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,
+      type: item.type,
+      metadata: item.metadata,
+      nbt: item.nbt,
+      durability,        // Оставшаяся прочность
+      maxDurability,     // Максимальная прочность
+      damage             // Использованная прочность
+    };
+  }
+
+  if (pinId === 'isEmpty') {
+    return !item;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/has_item.js

@@ -0,0 +1,35 @@
+/**
+ * inventory:has_item - Проверить наличие предмета в инвентаре
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const itemName = await helpers.resolvePinValue(node, 'itemName');
+  const minCount = (await helpers.resolvePinValue(node, 'minCount')) ?? 1;
+
+  if (!bot?.inventory || !itemName) {
+    if (pinId === 'hasItem') return false;
+    if (pinId === 'actualCount') return 0;
+    return null;
+  }
+
+  // Подсчитываем общее количество предмета
+  const searchName = itemName.toLowerCase().replace('minecraft:', '');
+  const actualCount = bot.inventory.items()
+    .filter(i =>
+      i.name.toLowerCase().includes(searchName) ||
+      i.displayName?.toLowerCase().includes(searchName)
+    )
+    .reduce((sum, item) => sum + item.count, 0);
+
+  if (pinId === 'hasItem') {
+    return actualCount >= minCount;
+  }
+
+  if (pinId === 'actualCount') {
+    return actualCount;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/inventory/select_slot.js

@@ -0,0 +1,46 @@
+/**
+ * inventory:select_slot - Выбрать слот хотбара
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+  const slot = await helpers.resolvePinValue(node, 'slot');
+
+  if (pinId === 'exec') {
+    return true; // Exec output
+  }
+
+  if (!bot?.inventory || slot === undefined || slot === null) {
+    if (pinId === 'item') return null;
+    return null;
+  }
+
+  try {
+    // Валидация номера слота (0-8)
+    const slotNumber = Math.max(0, Math.min(8, parseInt(slot)));
+
+    // Устанавливаем выбранный слот
+    bot.setQuickBarSlot(slotNumber);
+
+    if (pinId === 'item') {
+      // Возвращаем предмет в выбранном слоте
+      const item = bot.inventory.slots[slotNumber + 36]; // Хотбар начинается с 36
+      if (!item) return null;
+
+      return {
+        name: item.name,
+        displayName: item.displayName,
+        count: item.count,
+        slot: item.slot,
+        type: item.type,
+        metadata: item.metadata
+      };
+    }
+  } catch (error) {
+    console.error('[inventory:select_slot] Error:', error.message);
+    if (pinId === 'item') return null;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };

package/backend/src/core/nodes/navigation/follow.js

@@ -0,0 +1,51 @@
+const { goals } = require('mineflayer-pathfinder');
+
+/**
+ * navigation:follow - Следовать за игроком
+ */
+async function evaluate(node, pinId, context, helpers) {
+  const bot = context.bot;
+
+  if (pinId === 'exec') {
+    return true;
+  }
+
+  if (!bot?.pathfinder) {
+    if (pinId === 'following') return false;
+    return null;
+  }
+
+  const target = await helpers.resolvePinValue(node, 'target');
+  const range = (await helpers.resolvePinValue(node, 'range')) || 3;
+
+  if (!target) {
+    if (pinId === 'following') return false;
+    return null;
+  }
+
+  try {
+    const player = bot.players[target];
+
+    if (!player?.entity) {
+      console.error(`[navigation:follow] Player "${target}" not found or not visible`);
+      if (pinId === 'following') return false;
+      return null;
+    }
+
+    // Используем GoalFollow для непрерывного следования
+    const goal = new goals.GoalFollow(player.entity, range);
+    bot.pathfinder.setGoal(goal, true); // true = dynamic, обновляется при движении цели
+
+    if (pinId === 'following') {
+      return true;
+    }
+  } catch (error) {
+    console.error('[navigation:follow] Error:', error.message);
+
+    if (pinId === 'following') return false;
+  }
+
+  return null;
+}
+
+module.exports = { evaluate };