MURS вики

MURS:Специальные скрипты для особых задач: различия между версиями

← Предыдущая правка
отменитьTringoli (обсуждение | вклад)
Автомодерируемые
266 правок
ВизуальныйВики-текст
Доработки кода
Доработки кода
 
(не показана 1 промежуточная версия этого же участника)
Строка 1: Строка 1:
[[MURS:Строителям|← Вернуться к разделу «MURS:Строителям»]]
{{MURS:Строителям}}


== ==
'''Специальные скрипты для особых задач''' — подборка клиентских и серверных автоматизированных сценариев на базе JavaScript для ускорения рутинных процессов строительства в [[Муроморск|Муроморске]] и [[Муроморская область|Муроморской области]].
'''Специальные скрипты для особых задач''' — подборка клиентских и серверных автоматизированных сценариев на базе JavaScript для ускорения рутинных процессов строительства в [[Муроморск|Муроморске]] и [[Муроморская область|Муроморской области]].


Строка 39: Строка 40:
// =========================================================================
// =========================================================================


const radius = 15;        // Радиус сканирования вокруг игрока
const radius = 20;        // Радиус сканирования вокруг игрока
const lightRatio = 0.3;  // Шанс горящего окна (30% свет, 70% тьма)
const lightRatio = 0.3;  // Шанс горящего окна (30% свет, 70% тьма)
const blocksPerTick = 4;  // Ускорение (4 блока за 1 тик = 80 блоков/сек)
const blocksPerTick = 4;  // Скорость застройки (4 блока за 1 тик = 80 блоков/сек)
const silentMode = true;  // 🤫 ТИХИЙ РЕЖИМ: глушит системный спам команд в чат


// Идентификаторы блоков света и тьмы
// Идентификаторы блоков света и тьмы
Строка 49: Строка 51:
const player = Player.getPlayer();
const player = Player.getPlayer();


// Главный вектор взгляда игрока вглубь здания
// Главный вектор взгляда игрока по сетке
function getPlayerInwardVector() {
function getPlayerInwardVector() {
     let yaw = player.getYaw() % 360;
     let yaw = player.getYaw() % 360;
     if (yaw < 0) yaw += 360;
     if (yaw < 0) yaw += 360;
   
 
     if (yaw >= 315 || yaw < 45) return { dx: 0, dz: 1 };  // Взгляд на Юг -> комната на Юге (+Z)
     if (yaw >= 315 || yaw < 45) return { dx: 0, dz: 1 };  // Взгляд на Юг -> комната на Юге (+Z)
     if (yaw >= 45 && yaw < 135) return { dx: -1, dz: 0 };  // Взгляд на Запад -> комната на Западе (-X)
     if (yaw >= 45 && yaw < 135) return { dx: -1, dz: 0 };  // Взгляд на Запад -> комната на Западе (-X)
Строка 67: Строка 69:
let lookZ = Math.cos(yawRad);
let lookZ = Math.cos(yawRad);


// Проверка: находится ли окно перед игроком
// 🛡 Проверка сектора перед глазами игрока
function isInFront(x, z, px, pz) {
function isInFront(x, z, px, pz) {
     let dirX = x - px;
     let dirX = x - px;
Строка 73: Строка 75:
     if (dirX === 0 && dirZ === 0) return true;
     if (dirX === 0 && dirZ === 0) return true;
     let dot = dirX * lookX + dirZ * lookZ;
     let dot = dirX * lookX + dirZ * lookZ;
     return dot > -1.5;  
     return dot > -2.0;
}
}


// 🔍 ПРОВЕРКА: является ли блок окном (с фильтром внешних рамок)
// 🔍 ПРОВЕРКА ОКНА (Vanilla, Blockus, Macaw's, Chisel, Yuushya, Chipped)
function isWindow(id) {
function isWindow(id) {
    if (!id) return false;
     let s = String(id).toLowerCase();
     let s = String(id).toLowerCase();
   
 
     // 🚫 Исключаем внешние парапеты, перила и декоративные планки
     // 🚫 1. Исключаем дорожные моды (alt_fabroads)
     if (s.includes("sideway_frame") ||  
     if (s.startsWith("alt_fabroads:") ||
         s.includes("parapet") ||  
        s.startsWith("fabroads:") ||
         s.includes("railing") ||  
        s.includes("asphalt") ||
         s.includes("balcony") ||  
         s.includes("marking") ||
         s.includes("mullion") ||  
         s.includes("curb") ||
         s.includes("window_sill")) {
         s.includes("traffic") ||
         s.includes("road_sign") ||
         s.includes("road")) {
         return false;
         return false;
    }
        }
 
        // 🚫 2. Исключаем конструктивные элементы фасадов, шторы и ограждения
        if (s.includes("sideway_frame") ||
            s.includes("parapet") ||
            s.includes("railing") ||
            s.includes("balcony_railing") ||
            s.includes("curtain") ||
            s.includes("roof") ||
            s.includes("fence") ||
            s.includes("shutter")) {
            return false;
            }


    return s.match(/yuushya:.*(window|glass|diagonal).*/) ||  
            // 🌟 3. Поддержка всех типов стекла
          s.match(/chipped:.*(glass|pane|window).*/) ||  
            return s.includes("window") ||
          s.match(/mcwwindows:.*(window|glass|pane).*/) ||  
            s.includes("glass") ||
          s.match(/chisel:.*glass.*/) ||  
            s.includes("pane") ||
          s.match(/minecraft:.*glass.*/) ||
            s.includes("beveled") ||
          s.match(/.*:.*(window|stained_glass|glass_pane).*/);
            s.includes("diagonal") ||
            s.includes("frosted") ||
            s.includes("stained_glass") ||
            (s.startsWith("yuushya:") && (s.includes("white_") || s.includes("black_") || s.includes("brown_") || s.includes("classical_")) && s.includes("diagonal"));
}
}


// 🚫 ПРОВЕРКА КРАЙНИХ ЧАСТЕЙ (Подоконники и верхние карнизы)
// Проверка на воздух или заменяемый блок
function isEdgePart(id) {
function isAirOrReplaceable(id) {
    if (!id) return true;
     let s = String(id).toLowerCase();
     let s = String(id).toLowerCase();
     return s.includes("_bottom") ||  
     return s.includes("air") || s === "minecraft:light" || s.includes("structure_void");
          s.includes("_top") ||  
}
          s.includes("window_bottom") ||
 
          s.includes("window_top") ||
// Проверка на твердый блок стены здания
          s.includes("sill") ||
function isSolidWallBlock(x, y, z) {
          s.includes("_lower") ||
    let id = World.getBlock(x, y, z).getId();
          s.includes("_upper") ||
    if (isAirOrReplaceable(id)) return false;
          s.includes("parapet");
    if (id === blockLight || id === blockDark) return false;
    if (isWindow(id)) return false;
    return true;
}
}


// 🧬 УМНОЕ ОПРЕДЕЛЕНИЕ СЕМЕЙСТВА ОКНА (Нормализация для разных модов)
// 📐 ЛОКАЛЬНЫЙ РАСЧЁТ ПРИЛЕГАЮЩЕЙ ТОЧКИ ДЛЯ СЛОЖНЫХ УГЛОВ (22.5°, 45°, 60°, дуги)
function getWindowFamily(id) {
function getBestCurvedInteriorTarget(x, y, z, px, pz) {
     let s = String(id).toLowerCase();
     let candidates = [
        { dx: 0, dz: 1 },
        { dx: 0, dz: -1 },
        { dx: 1, dz: 0 },
        { dx: -1, dz: 0 }
    ];
 
    let winDistSq = (x - px) * (x - px) + (z - pz) * (z - pz);
    let vecX = x - px;
    let vecZ = z - pz;
 
    // Соседи-стекла для определения локальной касательной к стене
    let glassEast  = isWindow(World.getBlock(x + 1, y, z).getId());
    let glassWest  = isWindow(World.getBlock(x - 1, y, z).getId());
    let glassSouth = isWindow(World.getBlock(x, y, z + 1).getId());
    let glassNorth = isWindow(World.getBlock(x, y, z - 1).getId());
 
    let wallX = glassEast || glassWest || isSolidWallBlock(x + 1, y, z) || isSolidWallBlock(x - 1, y, z);
    let wallZ = glassSouth || glassNorth || isSolidWallBlock(x, y, z + 1) || isSolidWallBlock(x, y, z - 1);
 
    let bestTarget = null;
    let bestScore = -999999;


     // 1. Мод Chisel (chisel:light/glass, chisel:shale/glass, chisel:noborder/glass)
     for (let i = 0; i < candidates.length; i++) {
    if (s.startsWith("chisel:")) {
         let c = candidates[i];
         let colorMatch = s.match(/(white|orange|magenta|light_blue|yellow|lime|pink|gray|light_gray|cyan|purple|blue|brown|green|red|black)_glass/);
         let tx = x + c.dx;
         if (colorMatch) {
         let ty = y;
            return `chisel:${colorMatch[1]}_glass`;
         let tz = z + c.dz;
         }
         return "chisel:glass";
    }


    // 2. Мод Macaw's Windows (mcwwindows:spruce_plank_window, mcwwindows:stripped_spruce_log_window)
         let bId = World.getBlock(tx, ty, tz).getId();
    if (s.startsWith("mcwwindows:")) {
         let materials = [
            "spruce", "oak", "birch", "dark_oak", "jungle", "acacia",
            "mangrove", "cherry", "bamboo", "crimson", "warped", "iron",
            "quartz", "stone", "granite", "diorite", "andesite", "brick"
        ];
        for (let i = 0; i < materials.length; i++) {
            let mat = materials[i];
            if (s.includes(mat)) {
                return `mcwwindows:${mat}`;
            }
        }
        s = s.replace(/_(plank|stripped|log|pane|window|tall|gothic|parapet|four|two|single|double)$/g, "");
        return s;
    }


    // 3. Мод Yuushya (yuushya:white_windows_0/1/2, classical_white_window_top)
        // 🛑 Нельзя ставить в другое стекло или в толщу стены
    if (s.startsWith("yuushya:")) {
        if (isWindow(bId) || isSolidWallBlock(tx, ty, tz)) continue;
        s = s.replace(/_(\d+|bottom|middle|top|upper|lower|left|right|center|corner|diagonal|part\d*|sideway_frame)$/g, "");
        s = s.replace(/_(\d+|bottom|middle|top|upper|lower|left|right|center|corner|diagonal|part\d*|sideway_frame)$/g, "");
        return s;
    }


    // 4. Ванилла и Chipped
        // Точка должна быть воздухом или существующим блоком света
    s = s.replace(/_(\d+|bottom|middle|top|upper|lower|left|right|center|corner|diagonal|part\d*)$/g, "");
        if (!isAirOrReplaceable(bId) && bId !== blockLight && bId !== blockDark) continue;
    s = s.replace(/_(\d+|bottom|middle|top|upper|lower|left|right|center|corner|diagonal|part\d*)$/g, "");
   
    return s;
}


// 📐 СТРОГОЕ ВЕКТОРНОЕ ОПРЕДЕЛЕНИЕ ТОЧКИ ИНТЕРЬЕРА
        // 🛡 Точка обязана быть глубже в здании, чем стекло (не на улице!)
function getExactInteriorTarget(x, y, z, px, pz) {
        let targetDistSq = (tx - px) * (tx - px) + (tz - pz) * (tz - pz);
    let block = World.getBlock(x, y, z);
        if (targetDistSq < winDistSq - 0.05) continue;
    let blockFacing = null;


    try {
         let score = 0;
         let state = block.getBlockState();
        if (state) {
            try {
                let f = state.get("facing");
                if (f) blockFacing = String(f).toLowerCase();
            } catch(e) {}


            if (!blockFacing) {
        // 1. Проекция на вектор вглубь здания от игрока
                let str = String(state);
        let dotRay = c.dx * vecX + c.dz * vecZ;
                let match = str.match(/facing[=:]\s*([a-z_]+)/i);
        score += dotRay * 20;
                if (match) blockFacing = match[1].toLowerCase();
            }
        }
    } catch(e) {}


    let dx = 0, dz = 0;
        // 2. Перпендикулярность локальной линии стены
        if (wallX && !wallZ && c.dz !== 0) score += 60; // Локальная стена по X -> нормаль Z
        if (wallZ && !wallX && c.dx !== 0) score += 60; // Локальная стена по Z -> нормаль X


    if (blockFacing) {
        // 3. Анализ замкнутости помещения (наличие пола/потолка/внутренних перегородок)
         if (blockFacing.includes("south")) dz = -1;
         let surrounding = [
         else if (blockFacing.includes("north")) dz = 1;
            {ox: 0, oy: 1, oz: 0}, {ox: 0, oy: -1, oz: 0},
         else if (blockFacing.includes("east")) dx = -1;
            {ox: 1, oy: 0, oz: 0}, {ox: -1, oy: 0, oz: 0},
        else if (blockFacing.includes("west")) dx = 1;
            {ox: 0, oy: 0, oz: 1}, {ox: 0, oy: 0, oz: -1}
    }
        ];
         let enclosed = 0;
         for (let s = 0; s < surrounding.length; s++) {
            let sid = World.getBlock(tx + surrounding[s].ox, ty + surrounding[s].oy, tz + surrounding[s].oz).getId();
            if (!isAirOrReplaceable(sid)) enclosed++;
        }
        score += enclosed * 5;


    if (dx === 0 && dz === 0) {
        if (score > bestScore) {
        dx = mainInward.dx;
            bestScore = score;
        dz = mainInward.dz;
            bestTarget = { x: tx, y: ty, z: tz };
        }
     }
     }


     let winDistSq = (x - px) * (x - px) + (z - pz) * (z - pz);
     if (bestTarget) return bestTarget;
    let targetDistSq = ((x + dx) - px) * ((x + dx) - px) + ((z + dz) - pz) * ((z + dz) - pz);


     if (targetDistSq < winDistSq) {
    // Резервный расчет по направлению взгляда
         dx = -dx;
     if (Math.abs(vecZ) >= Math.abs(vecX)) {
         dz = -dz;
         let dz = (vecZ >= 0) ? 1 : -1;
         return { x: x, y: y, z: z + dz };
    } else {
        let dx = (vecX >= 0) ? 1 : -1;
        return { x: x + dx, y: y, z: z };
     }
     }
    return { x: x + dx, y: y, z: z + dz };
}
}


// 🛡 ЛОКАЛЬНАЯ ПРОВЕРКА СУЩЕСТВУЮЩИХ БЛОКОВ
// 🛡 Проверка наличия уже установленного цвета в соседней точке
function getLocalExistingBlock(targetX, targetY, targetZ) {
function getLocalExistingBlock(targetX, targetY, targetZ) {
     let offsets = [
     let offsets = [
Строка 223: Строка 240:


let visited = new Set();
let visited = new Set();
let targetedCoords = new Set();
let tasksToBuild = [];
let tasksToBuild = [];


Строка 229: Строка 247:
}
}


Chat.log(`§e[Урбанист] §fСканирую фасад (Нормализация модов Macaw's / Chisel / Yuushya: §aАКТИВНА§f)...`);
Chat.log(`§e[Урбанист] §fСканирую фасад (Фикс кривых углов 22.5°/45°/60°: §aАКТИВЕН§f)...`);


// 1. Поиск и группировка окон (Flood Fill)
// 1. Поиск и группировка окон (8-направленный Flood Fill для сбора ломаных стен)
for (let x = px - radius; x <= px + radius; x++) {
for (let x = px - radius; x <= px + radius; x++) {
     for (let y = py - radius; y <= py + radius; y++) {
     for (let z = pz - radius; z <= pz + radius; z++) {
         for (let z = pz - radius; z <= pz + radius; z++) {
 
           
        if (!isInFront(x, z, px, pz)) continue;
 
         for (let y = py - radius; y <= py + radius; y++) {
 
             let key = getPosKey(x, y, z);
             let key = getPosKey(x, y, z);
             if (visited.has(key)) continue;
             if (visited.has(key)) continue;


             let blockId = World.getBlock(x, y, z).getId();
             let blockId = World.getBlock(x, y, z).getId();
           
 
             if (isWindow(blockId)) {
             if (isWindow(blockId)) {
                if (!isInFront(x, z, px, pz)) {
                    visited.add(key);
                    continue;
                }
                let startFamily = getWindowFamily(blockId);
                 let stack = [{x: x, y: y, z: z}];
                 let stack = [{x: x, y: y, z: z}];
                 visited.add(key);
                 visited.add(key);


                 let groupTargets = [];
                 let rawWindowBlocks = [];


                 while (stack.length > 0) {
                 while (stack.length > 0) {
                     let curr = stack.pop();
                     let curr = stack.pop();
                     let currId = World.getBlock(curr.x, curr.y, curr.z).getId();
                     rawWindowBlocks.push(curr);
 
                    if (!isEdgePart(currId)) {
                        let target = getExactInteriorTarget(curr.x, curr.y, curr.z, px, pz);
                        let behindId = World.getBlock(target.x, target.y, target.z).getId();
 
                        if (behindId === "minecraft:air" || behindId === "minecraft:cave_air") {
                            groupTargets.push({ targetX: target.x, targetY: target.y, targetZ: target.z });
                        }
                    }


                     let neighbors = [
                     let neighbors = [
Строка 272: Строка 278:
                         {x: curr.x, y: curr.y - 1, z: curr.z},
                         {x: curr.x, y: curr.y - 1, z: curr.z},
                         {x: curr.x, y: curr.y, z: curr.z + 1},
                         {x: curr.x, y: curr.y, z: curr.z + 1},
                         {x: curr.x, y: curr.y, z: curr.z - 1}
                         {x: curr.x, y: curr.y, z: curr.z - 1},
                        // Диагональные связки для ступенчатых углов 22.5°/45°/60°
                        {x: curr.x + 1, y: curr.y, z: curr.z + 1},
                        {x: curr.x + 1, y: curr.y, z: curr.z - 1},
                        {x: curr.x - 1, y: curr.y, z: curr.z + 1},
                        {x: curr.x - 1, y: curr.y, z: curr.z - 1}
                     ];
                     ];


Строка 278: Строка 289:
                         let n = neighbors[i];
                         let n = neighbors[i];
                         let nKey = getPosKey(n.x, n.y, n.z);
                         let nKey = getPosKey(n.x, n.y, n.z);
                       
 
                         if (!visited.has(nKey)) {
                         if (!visited.has(nKey)) {
                             if (Math.abs(n.x - px) <= radius && Math.abs(n.y - py) <= radius && Math.abs(n.z - pz) <= radius) {
                             if (Math.abs(n.x - px) <= radius && Math.abs(n.y - py) <= radius && Math.abs(n.z - pz) <= radius) {
                                 let nId = World.getBlock(n.x, n.y, n.z).getId();
                                 let nId = World.getBlock(n.x, n.y, n.z).getId();
                               
 
                                // 🌟 Собираем соседние блоки, если они из одного семейства мода
                                 if (isWindow(nId)) {
                                 if (isWindow(nId) && getWindowFamily(nId) === startFamily) {
                                     visited.add(nKey);
                                     visited.add(nKey);
                                     stack.push(n);
                                     stack.push(n);
Строка 293: Строка 303:
                 }
                 }


                 if (groupTargets.length > 0) {
                 if (rawWindowBlocks.length > 0) {
                     let defaultGroupBlock = (Math.random() <= lightRatio) ? blockLight : blockDark;
                     let groupTargets = [];
                    let existingBlockInGroup = null;
 
                    for (let b = 0; b < rawWindowBlocks.length; b++) {
                        let wBlock = rawWindowBlocks[b];
 
                        // Локальный расчёт для каждой ступени криволинейного окна
                        let target = getBestCurvedInteriorTarget(wBlock.x, wBlock.y, wBlock.z, px, pz);
                        let behindId = World.getBlock(target.x, target.y, target.z).getId();
 
                        if (behindId === blockLight || behindId === blockDark) {
                            existingBlockInGroup = behindId;
                        } else if (isAirOrReplaceable(behindId)) {
                            let tKey = getPosKey(target.x, target.y, target.z);
                            if (!targetedCoords.has(tKey)) {
                                targetedCoords.add(tKey);
                                groupTargets.push({ targetX: target.x, targetY: target.y, targetZ: target.z });
                            }
                        }
                    }
 
                    if (groupTargets.length > 0) {
                        let chosenBlock = existingBlockInGroup;


                    for (let k = 0; k < groupTargets.length; k++) {
                        if (!chosenBlock) {
                        let t = groupTargets[k];
                            for (let k = 0; k < groupTargets.length; k++) {
                        let localExist = getLocalExistingBlock(t.targetX, t.targetY, t.targetZ);
                                let local = getLocalExistingBlock(groupTargets[k].targetX, groupTargets[k].targetY, groupTargets[k].targetZ);
                          
                                if (local) {
                         tasksToBuild.push({
                                    chosenBlock = local;
                            targetX: t.targetX,
                                    break;
                            targetY: t.targetY,
                                }
                            targetZ: t.targetZ,
                            }
                            blockToPlace: localExist ? localExist : defaultGroupBlock
                         }
                        });
 
                         if (!chosenBlock) {
                            chosenBlock = (Math.random() <= lightRatio) ? blockLight : blockDark;
                        }
 
                        for (let k = 0; k < groupTargets.length; k++) {
                            let t = groupTargets[k];
                            tasksToBuild.push({
                                targetX: t.targetX,
                                targetY: t.targetY,
                                targetZ: t.targetZ,
                                blockToPlace: chosenBlock
                            });
                        }
                     }
                     }
                 }
                 }
Строка 313: Строка 358:
}
}


Chat.log(`§e[Урбанист] §fСформировано корректных окон: §a${tasksToBuild.length}§f. Начинаю стройку!`);
let lightCount = 0;
let darkCount = 0;
 
for (let i = 0; i < tasksToBuild.length; i++) {
    if (tasksToBuild[i].blockToPlace === blockLight) lightCount++;
    else darkCount++;
}
 
Chat.log(`§e[Урбанист] §fНайдено ячеек: §a${tasksToBuild.length}§f (💡 Свет: §e${lightCount}§f, ⬛ Тьма: §7${darkCount}§f). Застройка...`);
 
// 🤫 2. Включаем тихий режим
if (silentMode && tasksToBuild.length > 0) {
    Chat.say(`/gamerule sendCommandFeedback false`);
    Client.waitTick(1);
}


let changed = 0;
let changed = 0;


// 2. Ускоренная застройка через /setblock
// 3. Застройка
for (let i = 0; i < tasksToBuild.length; i++) {
for (let i = 0; i < tasksToBuild.length; i++) {
     let task = tasksToBuild[i];
     let task = tasksToBuild[i];
Строка 323: Строка 382:
     Chat.say(`/setblock ${task.targetX} ${task.targetY} ${task.targetZ} ${task.blockToPlace}`);
     Chat.say(`/setblock ${task.targetX} ${task.targetY} ${task.targetZ} ${task.blockToPlace}`);
     changed++;
     changed++;
   
 
     if (changed % blocksPerTick === 0) {
     if (changed % blocksPerTick === 0) {
         Client.waitTick(1);  
         Client.waitTick(1);
     }
     }
}
}


Chat.log(`§e[Урбанист] §fУспешно застроено блоков за стёклами: §a${changed}`);
// 🔊 4. Возвращаем вывод команд обратно
if (silentMode && tasksToBuild.length > 0) {
    Client.waitTick(1);
    Chat.say(`/gamerule sendCommandFeedback true`);
}
 
Chat.log(`§a[Урбанист] §fЗастройка успешно завершена! Обработано блоков: §e${changed}`);
</syntaxhighlight>
</syntaxhighlight>


Источник — https://wiki.murs-mc.ru/wiki/MURS:Специальные_скрипты_для_особых_задач