blockmine 1.20.0 → 1.22.0

package/backend/src/core/nodes/bot/get_position.js

@@ -0,0 +1,20 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId === 'position') {
+        if (context.bot?.entity?.position) {
+            return context.bot.entity.position;
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,31 @@
+/**
+ * @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 === 'value') {
+        const numPins = node.data?.pinCount || 0;
+        const items = [];
+
+        for (let i = 0; i < numPins; i++) {
+            const value = await resolvePinValue(node, `pin_${i}`) ||
+                         node.data?.[`item_${i}`] ||
+                         node.data?.[`value_${i}`];
+            items.push(value);
+        }
+
+        return items;
+    }
+
+    return [];
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,21 @@
+/**
+ * @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 === 'value') {
+        return await resolvePinValue(node, 'value', false);
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,42 @@
+/**
+ * @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 === 'value') {
+        const value = await resolvePinValue(node, 'value');
+        const targetType = node.data?.targetType || 'String';
+
+        switch (targetType) {
+            case 'String':
+                // Для объектов и массивов используем JSON.stringify
+                if (typeof value === 'object' && value !== null) {
+                    try {
+                        return JSON.stringify(value);
+                    } catch (e) {
+                        return String(value ?? '');
+                    }
+                }
+                return String(value ?? '');
+            case 'Number':
+                const num = Number(value);
+                return isNaN(num) ? 0 : num;
+            case 'Boolean':
+                return ['true', '1', 'yes'].includes(String(value).toLowerCase());
+            default:
+                return value;
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,27 @@
+/**
+ * @param {object} node
+ * @param {string} pinId
+ * @param {object} context
+ * @param {object} helpers
+ * @returns {Promise<any>}
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'value') {
+        const dateString = await resolvePinValue(node, 'date', '');
+        if (dateString) {
+            const date = new Date(dateString);
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return new Date();
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,69 @@
+/**
+ * Нода для извлечения информации из объекта существа
+ * @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;
+
+    // Получаем объект существа из входного пина
+    const entity = await resolvePinValue(node, 'entity');
+    
+    if (!entity) {
+        // Возвращаем значения по умолчанию если существо не передано
+        if (pinId === 'type') return null;
+        if (pinId === 'username') return null;
+        if (pinId === 'distance') return null;
+        if (pinId === 'position') return null;
+        if (pinId === 'id') return null;
+        if (pinId === 'isPlayer') return false;
+        return null;
+    }
+
+    // Возвращаем нужное поле в зависимости от запрошенного выходного пина
+    switch (pinId) {
+        case 'type':
+            return entity.type || 'unknown';
+        
+        case 'username':
+            // Для игроков - username, для остальных - displayName или type
+            return entity.username || entity.displayName || entity.type || 'unknown';
+        
+        case 'distance':
+            // Вычисляем расстояние от бота до существа
+            if (entity.position && context.bot?.entity?.position) {
+                const botPos = context.bot.entity.position;
+                const entityPos = entity.position;
+                
+                const dx = entityPos.x - botPos.x;
+                const dy = entityPos.y - botPos.y;
+                const dz = entityPos.z - botPos.z;
+                const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+                
+                // Округляем до 2 знаков после запятой
+                return Math.round(distance * 100) / 100;
+            }
+            return null;
+        
+        case 'position':
+            return entity.position || null;
+        
+        case 'id':
+            return entity.id || null;
+        
+        case 'isPlayer':
+            return entity.type === 'player';
+        
+        default:
+            return null;
+    }
+}
+
+module.exports = {
+    evaluate,
+};
+

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

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers, defaultValue = null) {
+    const args = context.args || {};
+    const argName = node.data?.argumentName || '';
+
+    if (pinId === 'value') {
+        return args && argName && args[argName] !== undefined ? args[argName] : defaultValue;
+    } else if (pinId === 'exists') {
+        return args && argName && args[argName] !== undefined;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,14 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    return context.botState ? { yaw: context.botState.yaw, pitch: context.botState.pitch } : null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,18 @@
+/**
+ * @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, defaultValue = null) {
+    const { resolvePinValue } = helpers;
+
+    const entity = await resolvePinValue(node, 'entity');
+    return entity ? entity[pinId] : defaultValue;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,32 @@
+/**
+ * Нода для получения списка существ рядом с ботом
+ * @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 === 'entities') {
+        // Получаем радиус из входного пина (по умолчанию 32 блока)
+        const radius = await resolvePinValue(node, 'radius', 32);
+
+        // Получаем список существ через botApi
+        if (context.bot && context.bot.getNearbyEntities) {
+            const entities = await context.bot.getNearbyEntities(null, radius);
+            return entities || [];
+        }
+
+        return [];
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};
+

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_server_players.js

@@ -0,0 +1,18 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId === 'players') {
+        return context.players || [];
+    }
+
+    return [];
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,40 @@
+const User = require('../../UserService');
+
+/**
+ * @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, defaultValue = null) {
+    const { resolvePinValue } = helpers;
+
+    const userIdentifier = await resolvePinValue(node, 'user');
+    let userObject = null;
+
+    if (userIdentifier && typeof userIdentifier === 'object' && userIdentifier.username) {
+        userObject = userIdentifier;
+    } else if (typeof userIdentifier === 'string' && userIdentifier.length > 0) {
+        userObject = await User.getUser(userIdentifier, context.botId);
+    }
+
+    if (userObject) {
+        if (pinId === 'username') {
+            return userObject.username;
+        } else if (pinId === 'groups') {
+            return userObject.groups ? userObject.groups.map(g => g.group?.name).filter(Boolean) : [];
+        } else if (pinId === 'permissions') {
+            return userObject.permissionsSet ? Array.from(userObject.permissionsSet) : [];
+        } else if (pinId === 'isBlacklisted') {
+            return !!userObject.isBlacklisted;
+        }
+    }
+
+    return defaultValue;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    if (pinId === 'value') {
+        const varName = node.data?.variableName || node.data?.selectedVariable || '';
+        if (!varName) {
+            console.warn('[GraphExecutionEngine] data:get_variable: не указано имя переменной', node.data);
+            return null;
+        }
+        return context.variables.hasOwnProperty(varName) ? context.variables[varName] : null;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,25 @@
+/**
+ * @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 === 'length') {
+        const data = await resolvePinValue(node, 'data');
+        if (Array.isArray(data) || typeof data === 'string') {
+            return data.length;
+        }
+        return 0;
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,31 @@
+/**
+ * @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 === 'value') {
+        const numPins = node.data?.pinCount || 0;
+        const obj = {};
+
+        for (let i = 0; i < numPins; i++) {
+            const key = node.data[`key_${i}`];
+            if (key) {
+                obj[key] = await resolvePinValue(node, `value_${i}`);
+            }
+        }
+
+        return obj;
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,21 @@
+/**
+ * @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 === 'value') {
+        return await resolvePinValue(node, 'value', 0);
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +1,34 @@
+/**
+ * @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 === 'value') {
+        let text = String(node.data?.value || '');
+
+        // Парсим и заменяем переменные в формате {varName}
+        const variablePattern = /\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+        const matches = [...text.matchAll(variablePattern)];
+
+        for (const match of matches) {
+            const varName = match[1];
+            // Получаем значение из динамического пина
+            const varValue = await resolvePinValue(node, `var_${varName}`, '');
+            text = text.replace(match[0], String(varValue));
+        }
+
+        return text;
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

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

@@ -0,0 +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,
+};

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

@@ -0,0 +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,
+};