blockmine 1.21.0 → 1.22.0

package/backend/src/core/nodes/data/get_nearby_players.js

@@ -0,0 +1,64 @@
+/**
+ * Нода для получения списка игроков рядом с ботом с расстоянием до них
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'players') {
+        // Получаем радиус из входного пина (по умолчанию 32 блока)
+        const radius = await resolvePinValue(node, 'radius', 32);
+
+        // Получаем список всех существ через botApi
+        if (context.bot && context.bot.getNearbyEntities) {
+            const entities = await context.bot.getNearbyEntities(null, radius);
+            
+            // Фильтруем только игроков и добавляем расстояние
+            const players = [];
+            const botPosition = context.bot.entity?.position;
+            
+            for (const entity of entities) {
+                // Только игроки (type === 'player')
+                if (entity.type === 'player' && entity.position) {
+                    let distance = null;
+                    
+                    // Вычисляем расстояние, если известна позиция бота
+                    if (botPosition) {
+                        const dx = entity.position.x - botPosition.x;
+                        const dy = entity.position.y - botPosition.y;
+                        const dz = entity.position.z - botPosition.z;
+                        distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                        // Округляем до 2 знаков после запятой
+                        distance = Math.round(distance * 100) / 100;
+                    }
+                    
+                    players.push({
+                        username: entity.username,
+                        distance: distance,
+                        position: entity.position,
+                        id: entity.id
+                    });
+                }
+            }
+            
+            // Сортируем по расстоянию (ближайшие первыми)
+            players.sort((a, b) => (a.distance || 0) - (b.distance || 0));
+            
+            return players;
+        }
+
+        return [];
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};
+

package/backend/src/core/nodes/{data_get_user_field.js → data/get_user_field.js}

@@ -1,4 +1,4 @@
-const User = require('../UserService');
+const User = require('../../UserService');
 
 /**
  * @param {object} node - Экземпляр узла из графа.

package/backend/src/core/nodes/data/type_check.js

@@ -0,0 +1,53 @@
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+    const value = await resolvePinValue(node, 'value');
+    const checkType = node.data?.checkType || 'string';
+
+    if (pinId === 'result') {
+        switch (checkType) {
+            case 'string':
+                return typeof value === 'string';
+            
+            case 'number':
+                return typeof value === 'number' && !isNaN(value);
+            
+            case 'numeric_string':
+                // Проверяет, является ли значение строкой, которую можно преобразовать в число
+                if (typeof value !== 'string') return false;
+                const trimmed = value.trim();
+                if (trimmed === '') return false;
+                const num = Number(trimmed);
+                return !isNaN(num) && isFinite(num);
+            
+            case 'boolean':
+                return typeof value === 'boolean';
+            
+            case 'array':
+                return Array.isArray(value);
+            
+            case 'object':
+                return typeof value === 'object' && value !== null && !Array.isArray(value);
+            
+            case 'null':
+                return value === null || value === undefined;
+            
+            default:
+                return false;
+        }
+    }
+
+    if (pinId === 'type_name') {
+        // Возвращает строковое название типа
+        if (value === null) return 'null';
+        if (value === undefined) return 'undefined';
+        if (Array.isArray(value)) return 'array';
+        return typeof value;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};
+

package/backend/src/core/nodes/{debug_log.js → debug/log.js}

@@ -1,16 +1,16 @@
-/**
- * @param {object} node - The node instance from the graph.
- * @param {object} context - The execution context.
- * @param {object} helpers - Execution helpers.
- * @param {function} helpers.resolvePinValue - Function to resolve a pin's value.
- * @param {function} helpers.traverse - Function to continue execution to the next node.
- */
-async function execute(node, context, helpers) {
-    const value = await helpers.resolvePinValue(node, 'value');
-    console.log('[Graph Debug]', value);
-    await helpers.traverse(node, 'exec');
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - The node instance from the graph.
+ * @param {object} context - The execution context.
+ * @param {object} helpers - Execution helpers.
+ * @param {function} helpers.resolvePinValue - Function to resolve a pin's value.
+ * @param {function} helpers.traverse - Function to continue execution to the next node.
+ */
+async function execute(node, context, helpers) {
+    const value = await helpers.resolvePinValue(node, 'value');
+    console.log('[Graph Debug]', value);
+    await helpers.traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_branch.js → flow/branch.js}

@@ -1,15 +1,15 @@
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- */
-async function execute(node, context, helpers) {
-    const condition = await helpers.resolvePinValue(node, 'condition', false);
-    await helpers.traverse(node, condition ? 'exec_true' : 'exec_false');
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const condition = await helpers.resolvePinValue(node, 'condition', false);
+    await helpers.traverse(node, condition ? 'exec_true' : 'exec_false');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_break.js → flow/break.js}

@@ -1,14 +1,14 @@
-const BreakLoopSignal = require('../BreakLoopSignal');
-
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- */
-async function execute(node, context, helpers) {
-    throw new BreakLoopSignal();
-}
-
-module.exports = {
-    execute,
-};
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ */
+async function execute(node, context, helpers) {
+    throw new BreakLoopSignal();
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow/delay.js

@@ -0,0 +1,43 @@
+/**
+ * Узел задержки выполнения.
+ *
+ * Логика:
+ * - Ждет указанное количество миллисекунд.
+ * - После ожидания продолжает выполнение по выходу exec.
+ *
+ * Использование в графе:
+ * - Вход exec подключается от предыдущего действия.
+ * - Вход delay (Number) можно задать константой или подать с другого узла.
+ * - Выход exec соединяется с следующим действием.
+ */
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    // Значение задержки в миллисекундах.
+    // Можно задать как data.delay в ноде, либо через входной пин delay.
+    let delayMs = await resolvePinValue(node, 'delay', node.data?.delay ?? 0);
+
+    // Нормализуем значение
+    delayMs = Number(delayMs);
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+        delayMs = 0;
+    }
+
+    if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    await traverse(node, 'exec');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_for_each.js → flow/for_each.js}

@@ -1,39 +1,39 @@
-const BreakLoopSignal = require('../BreakLoopSignal');
-
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- * @param {Map} helpers.memo - Карта для мемоизации значений в рамках одного выполнения графа.
- * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации внутри тела цикла.
- */
-async function execute(node, context, helpers) {
-    const { resolvePinValue, traverse, memo, clearLoopBodyMemo } = helpers;
-
-    const array = await resolvePinValue(node, 'array', []);
-    if (Array.isArray(array)) {
-        try {
-            for (let i = 0; i < array.length; i++) {
-                const element = array[i];
-                memo.set(`${node.id}:element`, element);
-                memo.set(`${node.id}:index`, i);
-                clearLoopBodyMemo(node);
-                await traverse(node, 'loop_body');
-            }
-        } catch (e) {
-            if (e instanceof BreakLoopSignal) {
-                // Цикл был прерван узлом Break, это ожидаемое поведение.
-            } else {
-                // Перебрасываем другие, неожиданные ошибки.
-                throw e;
-            }
-        }
-    }
-    await traverse(node, 'completed');
-}
-
-module.exports = {
-    execute,
-};
+const BreakLoopSignal = require('../../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {Map} helpers.memo - Карта для мемоизации значений в рамках одного выполнения графа.
+ * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации внутри тела цикла.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo, clearLoopBodyMemo } = helpers;
+
+    const array = await resolvePinValue(node, 'array', []);
+    if (Array.isArray(array)) {
+        try {
+            for (let i = 0; i < array.length; i++) {
+                const element = array[i];
+                memo.set(`${node.id}:element`, element);
+                memo.set(`${node.id}:index`, i);
+                clearLoopBodyMemo(node);
+                await traverse(node, 'loop_body');
+            }
+        } catch (e) {
+            if (e instanceof BreakLoopSignal) {
+                // Цикл был прерван узлом Break, это ожидаемое поведение.
+            } else {
+                // Перебрасываем другие, неожиданные ошибки.
+                throw e;
+            }
+        }
+    }
+    await traverse(node, 'completed');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_sequence.js → flow/sequence.js}

@@ -1,16 +1,16 @@
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- */
-async function execute(node, context, helpers) {
-    const pinCount = node.data?.pinCount || 2;
-    for (let i = 0; i < pinCount; i++) {
-        await helpers.traverse(node, `exec_${i}`);
-    }
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const pinCount = node.data?.pinCount || 2;
+    for (let i = 0; i < pinCount; i++) {
+        await helpers.traverse(node, `exec_${i}`);
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_switch.js → flow/switch.js}

@@ -1,47 +1,47 @@
-/**
- * @param {object} node - Экземпляр узла из графа.
- * @param {object} context - Контекст выполнения графа.
- * @param {object} helpers - Вспомогательные функции движка.
- * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
- * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
- */
-async function execute(node, context, helpers) {
-    const { resolvePinValue, traverse } = helpers;
-
-    const value = await resolvePinValue(node, 'value');
-    const caseCount = node.data?.caseCount || 0;
-    let matched = false;
-    
-    for (let i = 0; i < caseCount; i++) {
-        const caseValue = node.data?.[`case_${i}`];
-        if (caseValue !== undefined) {
-            let isMatch = false;
-            
-            if (Array.isArray(value) && Array.isArray(caseValue)) {
-                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
-            } else if (typeof value === 'object' && typeof caseValue === 'object' && value !== null && caseValue !== null) {
-                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
-            } else if (typeof value === 'number' && typeof caseValue === 'number') {
-                isMatch = value === caseValue;
-            } else if (typeof value === 'boolean' && typeof caseValue === 'boolean') {
-                isMatch = value === caseValue;
-            } else {
-                isMatch = String(value) === String(caseValue);
-            }
-            
-            if (isMatch) {
-                await traverse(node, `case_${i}`);
-                matched = true;
-                break;
-            }
-        }
-    }
-    
-    if (!matched) {
-        await traverse(node, 'default');
-    }
-}
-
-module.exports = {
-    execute,
-};
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const value = await resolvePinValue(node, 'value');
+    const caseCount = node.data?.caseCount || 0;
+    let matched = false;
+
+    for (let i = 0; i < caseCount; i++) {
+        const caseValue = node.data?.[`case_${i}`];
+        if (caseValue !== undefined) {
+            let isMatch = false;
+
+            if (Array.isArray(value) && Array.isArray(caseValue)) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'object' && typeof caseValue === 'object' && value !== null && caseValue !== null) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'number' && typeof caseValue === 'number') {
+                isMatch = value === caseValue;
+            } else if (typeof value === 'boolean' && typeof caseValue === 'boolean') {
+                isMatch = value === caseValue;
+            } else {
+                isMatch = String(value) === String(caseValue);
+            }
+
+            if (isMatch) {
+                await traverse(node, `case_${i}`);
+                matched = true;
+                break;
+            }
+        }
+    }
+
+    if (!matched) {
+        await traverse(node, 'default');
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/{flow_while.js → flow/while.js}

@@ -1,4 +1,4 @@
-const BreakLoopSignal = require('../BreakLoopSignal');
+const BreakLoopSignal = require('../../BreakLoopSignal');
 
 /**
  * @param {object} node - Экземпляр узла из графа.

package/backend/src/core/nodes/logic/__tests__/compare.test.js

@@ -0,0 +1,83 @@
+describe('logic:compare node', () => {
+    const logicCompare = require('../compare');
+
+    const mockHelpers = (aValue, bValue) => ({
+        resolvePinValue: jest.fn(async (node, pinId) => {
+            if (pinId === 'a') return aValue;
+            if (pinId === 'b') return bValue;
+            return null;
+        }),
+    });
+
+    it('should compare greater than', async () => {
+        const node = { id: 'test', data: { operation: '>' } };
+        const helpers = mockHelpers(10, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare less than', async () => {
+        const node = { id: 'test', data: { operation: '<' } };
+        const helpers = mockHelpers(5, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare equals', async () => {
+        const node = { id: 'test', data: { operation: '==' } };
+        const helpers = mockHelpers(10, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare not equals', async () => {
+        const node = { id: 'test', data: { operation: '!=' } };
+        const helpers = mockHelpers(10, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare greater or equal', async () => {
+        const node = { id: 'test', data: { operation: '>=' } };
+        const helpers = mockHelpers(10, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should compare less or equal', async () => {
+        const node = { id: 'test', data: { operation: '<=' } };
+        const helpers = mockHelpers(5, 10);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should handle string comparison', async () => {
+        const node = { id: 'test', data: { operation: '<' } };
+        const helpers = mockHelpers('apple', 'banana');
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+
+    it('should default to equals if no operation specified', async () => {
+        const node = { id: 'test', data: {} };
+        const helpers = mockHelpers(5, 5);
+
+        const result = await logicCompare.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(true);
+    });
+});

package/backend/src/core/nodes/math/__tests__/operation.test.js

@@ -0,0 +1,65 @@
+describe('math:operation node', () => {
+    const mathOperation = require('../operation');
+
+    const mockHelpers = (aValue, bValue) => ({
+        resolvePinValue: jest.fn(async (node, pinId, defaultValue) => {
+            if (pinId === 'a') return aValue;
+            if (pinId === 'b') return bValue;
+            return defaultValue;
+        }),
+    });
+
+    it('should add two numbers', async () => {
+        const node = { id: 'test', data: { operation: '+' } };
+        const helpers = mockHelpers(5, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(8);
+    });
+
+    it('should subtract two numbers', async () => {
+        const node = { id: 'test', data: { operation: '-' } };
+        const helpers = mockHelpers(10, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(7);
+    });
+
+    it('should multiply two numbers', async () => {
+        const node = { id: 'test', data: { operation: '*' } };
+        const helpers = mockHelpers(4, 5);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(20);
+    });
+
+    it('should divide two numbers', async () => {
+        const node = { id: 'test', data: { operation: '/' } };
+        const helpers = mockHelpers(20, 4);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(5);
+    });
+
+    it('should handle division by zero', async () => {
+        const node = { id: 'test', data: { operation: '/' } };
+        const helpers = mockHelpers(10, 0);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(0);
+    });
+
+    it('should default to addition if operation not specified', async () => {
+        const node = { id: 'test', data: {} };
+        const helpers = mockHelpers(5, 3);
+
+        const result = await mathOperation.evaluate(node, 'result', {}, helpers);
+
+        expect(result).toBe(8);
+    });
+});