Merge pull request 'feat(player): �� fullscreen-�� (APK/desktop)' (#34 ) from feat/player-native-app-no-fs-prompt-2026-06-15 into main

feat(player): не показывать fullscreen-оверлей в нативном приложении
В Android-приложении (Capacitor) и десктопе (Electron) WebView/окно уже на весь экран — стартовый оверлей «Нажми чтобы играть» избыточен (в браузере он нужен для user-gesture перед fullscreen, в нативе барьера нет). Теперь в нативном приложении игра запускается сразу: - IS_ANDROID_APP: детект по window.Capacitor + метке RubloxAndroid в UA; - IS_NATIVE_APP = desktop || android; - gameStarted инициализируется true в нативе → оверлей пропускается; - handleGameStart/handleMobileStart не дёргают requestFullscreen в нативе. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-15 19:25:05 +00:00 · 2026-06-15 22:14:26 +03:00 · 2026-06-15 17:27:43 +00:00 · 2026-06-15 20:17:27 +03:00 · 2026-06-15 05:21:27 +00:00 · 2026-06-15 06:46:58 +03:00
9 changed files with 1503 additions and 104 deletions
--- a/src/KubikonPlayer/GameMenu.jsx
+++ b/src/KubikonPlayer/GameMenu.jsx
@ -1,6 +1,7 @@
 import React, { useEffect, useState, useRef, useCallback } from 'react';
 import Icon from '../editor-shared/Icon';
 import { STORYS_addres, USER_addres } from '../api/API';
 import { MIXAMO_SKINS } from '../engine/PlayerController';
 const getToken = () => {
    try {
@ -43,6 +44,10 @@ const HUD = {
    font: '"Inter", system-ui, -apple-system, sans-serif',
 };
 // В десктоп-приложении (Electron) пункт «Полноэкранный режим» не нужен —
 // окно и так на весь экран. preload выставляет window.__RUBLOX_DESKTOP__.
 const IS_DESKTOP_APP = typeof window !== 'undefined' && !!window.__RUBLOX_DESKTOP__;
 const TABS = [
    { id: 'people',   icon: 'users',    title: 'Участники' },
    { id: 'settings', icon: 'settings', title: 'Настройки' },
@ -63,14 +68,24 @@ export default function GameMenu({
 }) {
    const [activeTab, setActiveTab] = useState('people');
-    // ESC закрывает меню. Регистрируем в capture-фазе чтобы не конфликтовать
+    // Закрытие меню:
-    // с pointer-lock логикой KubikonPlayer.
+    //   • НЕ fullscreen — Esc (классика)
    //   • Fullscreen    — Tab (Esc отдаётся браузеру для выхода из FS)
    // Регистрируем в capture-фазе чтобы не конфликтовать с pointer-lock.
    useEffect(() => {
        if (!visible) return;
        const onKey = (e) => {
-            if (e.key === 'Escape') {
+            const isFs = !!(typeof document !== 'undefined' && document.fullscreenElement);
            if (e.key === 'Escape' && !isFs) {
                e.stopPropagation();
                onClose();
                return;
            }
            if ((e.key === 'Tab' || e.code === 'Tab') && isFs) {
                e.preventDefault();
                e.stopPropagation();
                onClose();
                return;
            }
            // L/R hotkeys как в Godot
            if (e.key === 'l' || e.key === 'L') onExit?.();
@ -218,9 +233,21 @@ function TabBar({ activeTab, onTab }) {
 }
 // ════════════════════════════════════════════════════════════════════
-//  BottomBar — 3 кнопки: L Покинуть / R Возродиться / Esc Продолжить
+//  BottomBar — 3 кнопки: L Покинуть / R Возродиться / Esc(Tab) Продолжить
 // ════════════════════════════════════════════════════════════════════
 function BottomBar({ onExit, onRespawn, onResume }) {
    // В fullscreen Esc отдан браузеру (выход из FS) — меню закрывается
    // на Tab. В обычном режиме — Esc.
    const [resumeKey, setResumeKey] = useState(
        typeof document !== 'undefined' && document.fullscreenElement ? 'Tab' : 'Esc'
    );
    useEffect(() => {
        const onFsChange = () => {
            setResumeKey(document.fullscreenElement ? 'Tab' : 'Esc');
        };
        document.addEventListener('fullscreenchange', onFsChange);
        return () => document.removeEventListener('fullscreenchange', onFsChange);
    }, []);
    return (
        <div
            style={{
@ -233,7 +260,7 @@ function BottomBar({ onExit, onRespawn, onResume }) {
        >
            <ActionBtn hotkey="L" label="Покинуть" onClick={onExit} variant="ghost" />
            <ActionBtn hotkey="R" label="Возродиться" onClick={onRespawn} variant="ghost" />
-            <ActionBtn hotkey="Esc" label="Продолжить" onClick={onResume} variant="primary" />
+            <ActionBtn hotkey={resumeKey} label="Продолжить" onClick={onResume} variant="primary" />
        </div>
    );
 }
@ -565,19 +592,39 @@ function PlayerCard({ player, isMe, isFriend, isPending, onAddFriend }) {
    const username = String(player.username || '?');
    const color = colorForUser(Number(player.user_id || 0), username);
-    // Аватар: 1) skin PNG (картинка персонажа — bacon/imposter/etc) — главный
+    // Аватар: 1) skin PNG (картинка персонажа) — главный
    //         2) photo_thumb_b64 (аватар майнкрафтии, fallback)
    //         3) photo URL (старое поле — fallback)
    //         4) буква-инициал
    //
-    // Скины лежат в /kubikon-assets/characters/<slug>/avatar.png — это PNG
+    // 2026-06-14: Mixamo-скины (skin_y-bot, skin_x-bot и т.д.) лежат на
-    // персонажа в полный рост. Совпадает с Godot/exe-плеером.
+    // rublox-site в /character-assets/skins/<slug>.png. Legacy R15-скины
    // (skin_bacon-hair, skin_sigma-labubu) — в /kubikon-assets/characters/<slug>/avatar.png.
    // Mixamo-набор детектим по тому что в slug нет дефиса с known-legacy-словами.
    // Известные LEGACY R15-скины (бекон, импостер, сигма-лабубу и пр.):
    // их PNG лежит в /kubikon-assets/characters/<slug>/avatar.png.
    // ВСЁ ОСТАЛЬНОЕ что начинается на 'skin_' — это Mixamo
    // (с 2026-06-11 палитра заменена на 80 Mixamo-персонажей).
    const LEGACY_SKINS = new Set([
        'skin_bacon-hair', 'skin_sigma-labubu', 'skin_sparks-roblox',
        'skin_imposter', 'skin_cop', 'skin_baby',
        'skin_pizza', 'skin_burger', 'skin_taco',
    ]);
    let avatarUrl = null;
    let isSkin = false;
    if (player.skin && typeof player.skin === 'string') {
-        // cache-bust обязателен: на 2026-05-27 фиксили 404 на этом пути,
+        // ВАЛИДАЦИЯ: legacy R15-скины (bacon-hair и пр.) больше не существуют.
-        // браузеры успели закэшировать негативный ответ
+        // Если скин НЕ в наборе валидных Mixamo (80 шт) — показываем аватар
-        avatarUrl = `/kubikon-assets/characters/${player.skin}/avatar.png?v=2026_05_27`;
+        // дефолтного skin_y-bot (как и в самой игре 3D-модель валидируется).
        let skinId = player.skin;
        if (!MIXAMO_SKINS.has(skinId) && !skinId.startsWith('customskin:')) {
            skinId = 'skin_y-bot';
        }
        const base = (typeof window !== 'undefined'
            && window.location.hostname === 'localhost')
            ? 'http://localhost:3000'
            : 'https://rublox.pro';
        avatarUrl = `${base}/character-assets/skins/${skinId}.png?v=20260614`;
        isSkin = true;
    } else if (player.photo_thumb_b64) {
        avatarUrl = player.photo_thumb_b64.startsWith('data:')
@ -888,6 +935,7 @@ function TabSettings({ sceneRef }) {
            />
            <SettingsSection title="Экран" />
            {!IS_DESKTOP_APP && (
            <ArrowsRow
                label="Полноэкранный режим"
                hint="Развернуть игру на весь экран"
@ -904,6 +952,7 @@ function TabSettings({ sceneRef }) {
                    } catch (e) { /* ignore */ }
                }}
            />
            )}
            <SliderRow
                label="Качество графики"
                hint="Разрешение рендера и тени"
--- a/src/KubikonPlayer/KubikonPlayer.jsx
+++ b/src/KubikonPlayer/KubikonPlayer.jsx
@ -4,6 +4,7 @@ import { jwtDecode } from 'jwt-decode';
 import { Client } from 'colyseus.js';
 import * as Kubikon3DApi from '../api/Kubikon3DService';
 import { BabylonScene } from '../engine/BabylonScene';
 import { MIXAMO_SKINS } from '../engine/PlayerController';
 import { attachConsoleHook, devlogReset } from '../engine/devlog';
 import { MultiplayerSync } from '../engine/MultiplayerSync';
 import { REALTIME_WS } from '../api/API';
@ -24,6 +25,24 @@ import useDeviceType from '../hooks/useDeviceType';
 import KubikonMobileControls from './KubikonMobileControls';
 import GameLoadingScreen from './GameLoadingScreen';
 // В десктоп-приложении (Electron-обёртка rublox-desktop) окно уже на весь
 // экран без браузерной панели и без вкладок — fullscreen не нужен (раньше он
 // защищал от случайного Ctrl+W/Ctrl+T в браузере; в Electron этого риска нет).
 // preload выставляет window.__RUBLOX_DESKTOP__.
 const IS_DESKTOP_APP = typeof window !== 'undefined' && !!window.__RUBLOX_DESKTOP__;
 // В Android-приложении (Capacitor-обёртка rublox-android) WebView уже на весь
 // экран — браузерный fullscreen не нужен, а стартовый оверлей «Нажми чтобы
 // играть» избыточен (в браузере он нужен для user-gesture перед FS, в APK
 // этого барьера не требуется). Capacitor выставляет window.Capacitor.
 const IS_ANDROID_APP = typeof window !== 'undefined'
    && (!!window.Capacitor
        || /RubloxAndroid/i.test(navigator.userAgent || ''));
 // Объединённый признак «нативного приложения» (десктоп ИЛИ Android) — там,
 // где поведение совпадает (не дёргать fullscreen).
 const IS_NATIVE_APP = IS_DESKTOP_APP || IS_ANDROID_APP;
 // Плеер живёт на player.rublox.pro — он не знает SPA-роутов Майнкрафтии
 // (/kubikon, /login, /auth). Поэтому вместо navigate(...) делаем
 // явный window.location.assign на внешний домен.
@ -209,9 +228,11 @@ const KubikonPlayer = () => {
    const roomRef = useRef(null);
    /** MultiplayerSync (мост между room и Babylon-сценой). */
    const mpSyncRef = useRef(null);
-    /** Выбранный R15-скин текущего игрока (из rublox_equipped_skin).
+    /** Выбранный Mixamo-скин текущего игрока (из rublox_equipped_skin).
-     *  Грузится при старте, уходит в мультиплеер как modelType. */
+     *  Грузится при старте, уходит в мультиплеер как modelType.
-    const skinFolderRef = useRef('skin_bacon-hair');
+     *  2026-06-13: дефолт сменён с skin_bacon-hair на skin_y-bot
     *  (Игрек-Бот, новый Mixamo-каталог). */
    const skinFolderRef = useRef('skin_y-bot');
    const [meta, setMeta] = useState(null);          // { title, description, user_id, ... }
    const [forbidden, setForbidden] = useState(false);
@ -221,9 +242,16 @@ const KubikonPlayer = () => {
    const [loadingScreenCfg, setLoadingScreenCfg] = useState(null);
    const [loadProgress, setLoadProgress] = useState(0);
    // Раньше была стартовая заглушка «тапни чтобы начать» — убрали по
-    // фидбэку, она бесила. Теперь fullscreen опционально через кнопку
+    // фидбэку, она бесила. Этот state остался для совместимости.
    // в углу. Этот state остался для совместимости с handleMobileStart.
    const [mobileStartTapped, setMobileStartTapped] = useState(true);
    // 2026-06-14: вернулся стартовый клик-экран — теперь нужен чтобы
    // ВКЛЮЧИТЬ fullscreen и заблокировать Ctrl+W/Ctrl+T и др. системные
    // хоткеи. Без этого браузер закрывает вкладку при случайном Ctrl+W.
    // requestFullscreen() требует user gesture — поэтому без клика никак.
    // В нативном приложении (Electron/Capacitor) fullscreen не нужен (окно и
    // так на весь экран), поэтому стартовый оверлей пропускаем — игра
    // запускается сразу.
    const [gameStarted, setGameStarted] = useState(IS_NATIVE_APP);
    const [hp, setHp] = useState({ hp: 100, maxHp: 100 });
    // Скрипт через game.hud.setVisible(false) полностью скрывает стандартный HUD.
    const [stdHudVisible, setStdHudVisible] = useState(true);
@ -309,36 +337,59 @@ const KubikonPlayer = () => {
        return () => { active = false; };
    }, [projectId]);
-    // Перехват Ctrl-комбинаций которые ломают игру (Ctrl+W = закрыть вкладку,
+    // Перехват системных Ctrl-комбинаций которые в WASD-игре регулярно
-    // Ctrl+R = reload, Ctrl+T/N — мешают). Большинство браузеров блокирует
+    // нажимаются случайно и приводят к закрытию вкладки / открытию диалогов.
-    // отмену системных шорткатов, но beforeunload даёт пользователю шанс
+    // В fullscreen Chrome даёт большинству этих хоткеев preventDefault'иться.
-    // подтвердить выход. Также превентим preventDefault на keydown для
+    //
-    // случаев когда фокус НЕ на window-уровне (Chrome иногда позволяет).
+    // 2026-06-14: добавлены KeyD (закладка), KeyS (сохранить страницу),
    // KeyA (выделить всё), KeyP (печать), KeyU (исходник), KeyJ/KeyH (история).
    // Все буквы которые могут зажиматься с Ctrl во время WASD-управления.
    useEffect(() => {
        const onKey = (e) => {
-            if (!e.ctrlKey && !e.metaKey) return;
+            // 1. Системные F-клавиши и навигация в любой момент:
-            // Список «опасных» в игре сочетаний — превентим
+            //    F5 = reload, F11 = fullscreen toggle (нужен Esc-way),
-            const dangerousCodes = ['KeyW', 'KeyR', 'KeyT', 'KeyN'];
+            //    Backspace = browser back (если фокус не на input),
-            if (dangerousCodes.includes(e.code)) {
+            //    Tab — мешает фокусом UI.
            // F11 ОСТАВЛЯЕМ — даёт юзеру способ выйти из fullscreen.
            if (e.code === 'F5' || e.code === 'F3' || e.code === 'F6'
                || e.code === 'F7') {
                e.preventDefault(); e.stopPropagation(); return;
            }
            // 2. Ctrl/Cmd-комбинации. WASD-клавиши ОБРАБАТЫВАЕМ отдельно:
            // блокируем системное действие браузера (preventDefault), но
            // НЕ stopPropagation — иначе PlayerController не увидит ввод.
            // Игрок часто приседает (Ctrl) и одновременно идёт (W/A/S/D).
            if (e.ctrlKey || e.metaKey) {
                const wasd = ['KeyW', 'KeyA', 'KeyS', 'KeyD'];
                if (wasd.includes(e.code)) {
                    e.preventDefault();   // блокируем Ctrl+W (закрытие), Ctrl+D (закладка) и т.д.
                    return;                // НЕ stopPropagation — пусть PlayerController увидит
                }
                const blocked = [
                    'KeyR',  // reload
                    'KeyT',  // new tab
                    'KeyN',  // new window
                    'KeyP',  // print
                    'KeyU',  // view source
                    'KeyJ',  // downloads
                    'KeyH',  // history
                    'KeyF',  // find on page
                    'KeyG',  // find next
                    'KeyL',  // focus address bar
                    'KeyO',  // open file
                    'Tab',   // switch tab
                    'Digit1', 'Digit2', 'Digit3', 'Digit4', 'Digit5',
                    'Digit6', 'Digit7', 'Digit8', 'Digit9',
                ];
                if (blocked.includes(e.code)) {
                    e.preventDefault();
                    e.stopPropagation();
                }
-        };
+            }
        const onBeforeUnload = (e) => {
            // Если юзер сам нажал «Покинуть» в меню — пропускаем без
            // подтверждения. Флаг ставит exitPlayer().
            if (window.__rubloxExplicitExit) return undefined;
            // Случайное закрытие вкладки (Ctrl+W, X-кнопка) — показываем
            // подтверждение чтобы не потерять прогресс игры.
            e.preventDefault();
            e.returnValue = '';
            return '';
        };
        window.addEventListener('keydown', onKey, { capture: true });
        window.addEventListener('beforeunload', onBeforeUnload);
        return () => {
            window.removeEventListener('keydown', onKey, { capture: true });
            window.removeEventListener('beforeunload', onBeforeUnload);
        };
    }, []);
@ -589,17 +640,67 @@ const KubikonPlayer = () => {
                // тогда player.setModelType подхватит правильный скин.
                // Этот же skinFolder уйдёт в мультиплеер как modelType,
                // чтобы соперники видели наш реальный скин.
-                let mySkin = 'skin_bacon-hair';
+                //
-                if (userId) {
+                // LOCAL DEV (localhost): берём скин из URL #skin=<id>
                // (передаётся сайтом 3000 при нажатии «Играть»), потом из
                // localStorage самого плеера, потом дефолт. В БД НЕ лезем —
                // прод-БД хранит легаси скины (skin_sigma-labubu и др.),
                // которые мы не хотим грузить локально.
                //
                // PROD: только БД (rublox_equipped_skin).
                let mySkin = 'skin_y-bot';
                const isLocalDev = (typeof window !== 'undefined'
                    && (window.location.hostname === 'localhost'
                        || window.location.hostname === '127.0.0.1'));
                // Источник скина по приоритету:
                //   1) hash-параметр #skin=<id> в URL (передаёт сайт при play-ticket;
                //      работает и на localhost и на проде)
                //   2) БД через /equipped-skin (если есть userId)
                //   3) localStorage самого плеера (fallback на localhost для отладки)
                //   4) skin_y-bot (дефолт)
                try {
                    console.log('[KubikonPlayer] hash=', window.location.hash,
                        '| LS rublox_selected_skin=', (typeof localStorage !== 'undefined' ? localStorage.getItem('rublox_selected_skin') : '?'));
                    const m = window.location.hash.match(/[#&]skin=([\w-]+)/);
                    if (m && m[1]) {
                        mySkin = m[1];
                        console.log('[KubikonPlayer] skin from URL:', mySkin);
                    }
                } catch (e) {}
                if (mySkin === 'skin_y-bot' && userId) {
                    // 2) Лезем в БД (через прод-API). Бэк отдаёт либо
                    //    выбранный валидный скин, либо дефолт по полу.
                    try {
                        const skinRes = await Kubikon3DApi.getEquippedSkin(userId);
                        const sf = skinRes?.data?.skin_folder;
-                        if (sf && typeof sf === 'string') mySkin = sf;
+                        if (sf && typeof sf === 'string') {
                            mySkin = sf;
                            console.log('[KubikonPlayer] skin from DB:', mySkin);
                        }
                    } catch (e) {
                        // Сеть/ошибка — играем с дефолтным скином, не блокируем.
                        console.warn('[KubikonPlayer] equipped-skin load failed', e);
                    }
                }
                if (mySkin === 'skin_y-bot' && isLocalDev) {
                    // 3) Локальный fallback на localStorage плеера.
                    try {
                        const localPick = localStorage.getItem('rublox_selected_skin');
                        if (localPick && typeof localPick === 'string') {
                            mySkin = localPick;
                            console.log('[KubikonPlayer] skin from local LS:', mySkin);
                        }
                    } catch (e) {}
                }
                // ВАЛИДАЦИЯ: если скин не из валидного набора Mixamo-скинов
                // (legacy bacon-hair/sigma-labubu/cop и пр. — их больше нет,
                // или бэкенд вернул дефолтный bacon) — fallback на skin_y-bot.
                // Это защита: персонаж не должен пытаться загрузить несуществующий
                // скин. См. БД rublox_equipped_skin (22+ юзеров с bacon-hair).
                if (mySkin && !MIXAMO_SKINS.has(mySkin)
                    && !mySkin.startsWith('customskin:')) {
                    console.log('[KubikonPlayer] skin', mySkin, 'не валиден → skin_y-bot');
                    mySkin = 'skin_y-bot';
                }
                skinFolderRef.current = mySkin;
                try { scene.setPlayerModelType?.(mySkin); } catch (e) {}
@ -831,7 +932,7 @@ const KubikonPlayer = () => {
            // загружен при старте в skinFolderRef). Сервер всё равно перепроверит
            // скин по userId из JWT и при расхождении возьмёт значение из БД —
            // так каждый игрок виден соперникам в своём реальном скине.
-            const modelType = skinFolderRef.current || 'skin_bacon-hair';
+            const modelType = skinFolderRef.current || 'skin_y-bot';
            // Если у нас есть валидный reconnectionToken от прошлой сессии —
            // используем Colyseus reconnect (это та же сессия для сервера,
            // allowReconnection(5) её подхватит, не будет +join/-leave цикла).
@ -1044,12 +1145,29 @@ const KubikonPlayer = () => {
            || root.webkitRequestFullscreen
            || root.mozRequestFullScreen
            || root.msRequestFullscreen;
-        if (req) {
+        // В нативном приложении (Electron/Capacitor) окно и так на весь
        // экран — FS не нужен.
        if (req && !IS_NATIVE_APP) {
            try { await req.call(root); } catch (e) { /* отменено */ }
        }
        setMobileStartTapped(true);
    }, []);
    /** Стартовый клик «Начать игру» — запрашивает fullscreen
     *  (Chrome блокирует Ctrl+W/Ctrl+T в fullscreen) и снимает оверлей.
     *  В нативном приложении (Electron/Capacitor) FS не нужен. */
    const handleGameStart = useCallback(async () => {
        const root = document.documentElement;
        const req = root.requestFullscreen
            || root.webkitRequestFullscreen
            || root.mozRequestFullScreen
            || root.msRequestFullscreen;
        if (req && !IS_NATIVE_APP) {
            try { await req.call(root); } catch (e) { /* юзер запретил — играем без FS */ }
        }
        setGameStarted(true);
    }, []);
    // При выходе со страницы — снимаем fullscreen / orientation lock,
    // чтобы возврат в школу не остался залочен в landscape.
    useEffect(() => {
@ -1150,13 +1268,79 @@ const KubikonPlayer = () => {
                        outline: 'none',
                    }}
                />
-                {/* Задача 05: красивый экран загрузки игры (Ken Burns + название места + автор). */}
+                {/* GameLoadingScreen НЕ показывается при загрузке плейса.
-                {loading && (
+                 *  Появляется ТОЛЬКО когда автор вызовет его из скрипта игры
-                    <GameLoadingScreen
+                 *  (через game.showLoadingScreen или аналог). По дефолту — игра
-                        meta={meta}
+                 *  открывается сразу, как в Roblox. */}
-                        loadingScreen={loadingScreenCfg}
+
-                        progress={loadProgress}
+                {/* 2026-06-14: стартовый оверлей. Один клик → fullscreen →
-                    />
+                 *  Chrome блокирует Ctrl+W/Ctrl+T/Ctrl+R и др. Без него
                 *  юзер случайно закрывает вкладку, теряет прогресс. */}
                {!loading && !gameStarted && (
                    <div
                        onClick={handleGameStart}
                        style={{
                            position: 'absolute',
                            inset: 0,
                            background: 'rgba(7, 11, 26, 0.86)',
                            backdropFilter: 'blur(6px)',
                            zIndex: 2000,
                            display: 'flex',
                            flexDirection: 'column',
                            alignItems: 'center',
                            justifyContent: 'center',
                            color: '#fff',
                            cursor: 'pointer',
                            userSelect: 'none',
                        }}
                    >
                        <div style={{
                            fontSize: 36,
                            fontWeight: 800,
                            marginBottom: 14,
                            letterSpacing: '0.5px',
                        }}>
                            Нажми чтобы играть
                        </div>
                        <div style={{
                            fontSize: 16,
                            opacity: 0.75,
                            maxWidth: 480,
                            textAlign: 'center',
                            lineHeight: 1.4,
                            padding: '0 24px',
                        }}>
                            {IS_DESKTOP_APP ? (
                                <>Управление: <b>WASD</b> — движение, <b>пробел</b> — прыжок,
                                мышь — камера.</>
                            ) : (
                                <>
                                    Игра откроется в полноэкранном режиме —
                                    это защитит от случайного закрытия вкладки
                                    (Ctrl+W, Ctrl+T и др.).
                                    <br />
                                    Выход: <b>Esc</b> или <b>F11</b>.
                                </>
                            )}
                        </div>
                        <button
                            type="button"
                            style={{
                                marginTop: 28,
                                padding: '14px 38px',
                                fontSize: 18,
                                fontWeight: 700,
                                background: 'linear-gradient(135deg,#4f7df0,#2563eb)',
                                border: 'none',
                                borderRadius: 12,
                                color: '#fff',
                                cursor: 'pointer',
                                boxShadow: '0 6px 18px rgba(37,99,235,0.45)',
                            }}
                        >
                            ▶ Начать
                        </button>
                    </div>
                )}
                {/* Игровой UI (HUD, GUI, hotbar, прицел в первом лице) */}
@ -1397,11 +1581,14 @@ const KubikonPlayer = () => {
                        )}
                    </>
                )}
-                {/* Кнопка «полный экран» — маленькая, в правом верхнем углу,
+                {/* Кнопка «полный экран» — маленькая, в правом верхнем углу.
-                    только на тач-устройствах. Браузеры требуют user gesture
+                    Показывается на ВСЕХ устройствах (desktop + touch):
-                    для requestFullscreen() — поэтому без кнопки никак.
+                    - touch — нужна чтобы скрыть UI браузера на телефоне
-                    Кнопка автоматически скрывается после входа в fullscreen. */}
+                    - desktop — в fullscreen Chrome блокирует Ctrl+W/Ctrl+T
-                {isTouch && !loading && !document.fullscreenElement && (
+                      и прочие системные хоткеи, которые иначе закрывают вкладку.
                    Браузеры требуют user gesture для requestFullscreen() —
                    поэтому без кнопки никак. */}
                {!loading && !document.fullscreenElement && (
                    <button
                        data-mobile-hud="fullscreen"
                        onClick={handleMobileStart}
@ -1419,7 +1606,7 @@ const KubikonPlayer = () => {
                            padding: 0,
                            WebkitTapHighlightColor: 'transparent',
                        }}
-                        title="Полноэкранный режим"
+                        title="Полный экран (блокирует Ctrl+W и др. системные хоткеи)"
                    >
                        <svg width="20" height="20" viewBox="0 0 24 24" fill="none">
                            <path d="M4 9V4h5M20 9V4h-5M4 15v5h5M20 15v5h-5"
--- a/src/engine/BabylonScene.js
+++ b/src/engine/BabylonScene.js
@ -199,10 +199,9 @@ export class BabylonScene {
        // Точка спавна игрока в режиме Play (обновляется setSpawnPoint)
        this._spawnPoint = { x: 0, y: 5, z: 0 };
        // Модель персонажа для режима Play.
-        // Дефолт — R15-скин bacon-hair (классический Roblox-вид).
+        // 2026-06-13: дефолт сменён на skin_y-bot (Mixamo Y-Bot,
-        // 'skin_*' грузится из characters/<id>/body.glb (R15-скелет),
+        // нейтральный по полу). Старые скины (skin_bacon-hair и др.) удалены.
-        // 'character-*' — старые Kenney-модели.
+        this._playerModelType = 'skin_y-bot';
        this._playerModelType = 'skin_bacon-hair';
        // Размер пола: пол идёт от -worldHalf до +worldHalf по X и Z.
        // По умолчанию 80×80 (worldHalf = 40). Можно менять через setWorldSize().
        this._worldHalf = 40;
@ -1788,8 +1787,8 @@ export class BabylonScene {
                const csm = new CascadedShadowGenerator(size, this._sunLight);
                csm.numCascades = numCascades;
                csm.stabilizeCascades = true;
-                csm.lambda = 0.6;
+                csm.lambda = 0.8;                  // 0.8 даёт больше детали ближе, меньше дальше → границы менее заметны
-                csm.cascadeBlendPercentage = 0.1;
+                csm.cascadeBlendPercentage = 0.35; // 0.10 → 0.35: плавный переход между каскадами (убирает резкие полосы на полу)
                csm.shadowMaxZ = (q === 'high') ? 90 : 60;
                csm.bias = PCF_BIAS;
                csm.normalBias = PCF_NORMAL_BIAS;
@ -1800,6 +1799,9 @@ export class BabylonScene {
                csm.darkness = 0.4;
                csm.autoCalcDepthBounds = false;
                csm.frustumEdgeFalloff = 12;       // убирает «полосу-хвост» тени игрока
                // depthClamp убирает обрезку shadow на границе depth — без этого
                // иногда видны тонкие линии где shadow texel «выпадает» за depth-bound.
                csm.depthClamp = true;
                this._shadowGenerator = csm;
            } else {
                // Обычный ShadowGenerator. Soft теперь 2048 (было 1024).
@ -5636,8 +5638,9 @@ export class BabylonScene {
        // поэтому скрипты стартуем в следующем кадре.
        this.gameRuntime = new GameRuntime(this);
        try { this.modalManager?.attachRuntime?.(this.gameRuntime); } catch (e) {}
-        // Задача 05: стартовый экран загрузки (Ken-Burns + название места).
+        // НЕ показывать стартовый экран загрузки автоматически.
-        try { this.showStartupLoadingScreen(); } catch (e) {}
+        // По дефолту игра открывается мгновенно (как в Roblox). Экран загрузки
        // только если автор явно вызовет showLoadingScreen() из скрипта.
        // Аудио-менеджер (GD-музыка/SFX) — создаётся вместе с runtime.
        // ВАЖНО: поле называется gameAudioManager чтобы не путать со штатным
        // this.audioManager (AudioManager — ambient/music для всех проектов).
@ -7523,7 +7526,9 @@ export class BabylonScene {
        // форсим R15 bacon-hair. Явно выбранные 'skin_*' не трогаем.
        if (state.scene.playerModelType) {
            const pmt = state.scene.playerModelType;
-            this._playerModelType = pmt.startsWith('character-') ? 'skin_bacon-hair' : pmt;
+            // character-a..g (Kenney) и legacy R15 (skin_bacon-hair и др.)
            // мигрируем на новый дефолт skin_y-bot.
            this._playerModelType = pmt.startsWith('character-') ? 'skin_y-bot' : pmt;
        }
        // Задача 07: конфиг скинов { default, unlocked, shopVisible, coins, customGlbs }.
        if (state.scene.skins && typeof state.scene.skins === 'object') {
--- a/src/engine/MixamoAnimator.js
+++ b/src/engine/MixamoAnimator.js
@ -0,0 +1,593 @@
 /**
 * MixamoAnimator — проигрывает Mixamo-анимации на скелете персонажа.
 *
 * Mixamo-скины (skin_y-bot, skin_x-bot, и ещё 78) приходят БЕЗ
 * AnimationGroups в их собственном GLB. Анимации лежат отдельными
 * GLB-файлами в /character-assets/animations/:
 *
 *   idle.glb, walk.glb, run.glb, jump.glb, fall.glb
 *   emote_capoeira.glb, emote_defeated.glb, emote_shoved.glb, emote_taunt.glb
 *
 * Каждый GLB содержит ровно одну AnimationGroup, нацеленную на bones
 * с именами `mixamorig:Hips`, `mixamorig:Spine` и т.д.
 *
 * Что делает этот класс:
 * 1. Загружает 5 базовых GLB параллельно и кэширует AnimationGroup'ы
 *    (singleton — один loader на сессию).
 * 2. Для конкретного скина РЕТАРГЕТИТ AnimationGroup на его кости.
 *    Mixamo-скины разных вышедших времён имеют префикс `mixamorig:`,
 *    `mixamorig9:` или вообще без префикса — детектим автоматически.
 * 3. Управление: `setState('idle'|'walk'|'run'|'jump'|'fall')` +
 *    плавный кросс-фейд (blending) между состояниями.
 * 4. `playEmote(name, onDone)` — одноразово проиграть эмоцию поверх,
 *    после конца автоматически вернуться в текущее состояние.
 *
 * Bone-имена которые ретаргетим (24 обязательных):
 *   Hips, Spine, Spine1, Spine2, Neck, Head,
 *   LeftShoulder, LeftArm, LeftForeArm, LeftHand,
 *   RightShoulder, RightArm, RightForeArm, RightHand,
 *   LeftUpLeg, LeftLeg, LeftFoot, LeftToeBase,
 *   RightUpLeg, RightLeg, RightFoot, RightToeBase
 *
 * Использование:
 *   const anim = new MixamoAnimator();
 *   await anim.load();                        // один раз на сессию
 *   anim.attach(scene, skeleton, modelRoot);  // на каждую загрузку скина
 *   anim.setState('idle');
 *   // каждый кадр в _tick (необязательно — Babylon сам тикает groups):
 *   anim.update(dt);
 *   // эмоция:
 *   anim.playEmote('emote_taunt');
 *   // при смене скина:
 *   anim.detach();
 */
 import { SceneLoader, AnimationGroup, Animation } from "@babylonjs/core";
 import "@babylonjs/loaders/glTF";
 // Базовые состояния — соответствуют файлам *.glb в animations/.
 // Базовые (всегда грузятся при старте — нужны для движения):
 const BASE_STATES = ["idle", "walk", "run", "jump", "fall"];
 // Дополнительные движения (грузятся лениво при первом setState):
 const EXTRA_STATES = [
    "jump_anticipate", "jump_air", "jump_land",
    "jump_fwd_anticipate", "jump_fwd_air", "jump_fwd_land",
    "jump_run_anticipate", "jump_run_air", "jump_run_land",
    "walk_backward", "run_backward", "run_to_stop", "run_slide",
    "jump_forward", "jump_backward", "jump_down",
    "crouch_enter", "crouch_idle", "crouch_walk", "crouch_to_stand",
    "climb_up", "climb_down", "climb_to_top", "sit_idle", "lie_idle", "sleeping",
    "hit_react", "die_forward", "die_back",
    "punch_left", "kick_low", "kick_high",
    "gun_fire", "gun_reload", "rifle_walk",
    "sword_idle", "sword_slash",
    "push_button", "open_door", "throw_action",
 ];
 // Эмоции (вызываются через playEmote()):
 const EMOTES = [
    "emote_capoeira", "emote_defeated", "emote_shoved", "emote_taunt",
    "emote_salute", "emote_pointing", "emote_no",
    "dance_hiphop", "dance_rumba", "dance_breakdance",
 ];
 // Все известные анимации (для опциональной полной предзагрузки)
 const ALL_ANIMATIONS = [...BASE_STATES, ...EXTRA_STATES, ...EMOTES];
 // Кэш сырых данных анимаций между инстансами (singleton-ish):
 // один раз загрузили — используем для всех аватаров.
 let _cachedRawTargets = null; // { idle: [{boneName, animations:[Anim]}], walk: [...] , ... }
 let _loadPromise = null;
 /**
 * Строит абсолютный URL для статики Mixamo-анимаций.
 * Локально — localhost:3000 (rublox-site dev-server),
 * на проде — rublox.pro/character-assets/.
 */
 function _assetsBase() {
    if (typeof window === "undefined") return "";
    const isLocal = window.location.hostname === "localhost"
        || window.location.hostname === "127.0.0.1";
    return isLocal ? "http://localhost:3000" : "https://rublox.pro";
 }
 /**
 * Нормализует имя кости: убирает префикс `mixamorig:`, `mixamorig9:`,
 * `mixamorig_` и т.п. Возвращает чистое имя типа `Hips`, `Spine`, `LeftArm`.
 */
 function _normalizeBone(name) {
    if (!name) return "";
    // mixamorig:Hips, mixamorig9:Hips, mixamorig_Hips, Armature|mixamorig:Hips, etc
    let n = name;
    const colon = n.lastIndexOf(":");
    if (colon >= 0) n = n.slice(colon + 1);
    n = n.replace(/^mixamorig\d*[_:.]?/i, "");
    n = n.replace(/^Armature\|/, "");
    return n;
 }
 /**
 * Загружает один GLB-файл с анимациями. Возвращает массив
 * { boneName, animations: [Babylon.Animation] } — сырые треки,
 * привязанные к именам костей (без префикса).
 */
 async function _loadAnimGlb(scene, url) {
    // ImportAnimations не годится — он сразу target-ит конкретный
    // скелет. Нам нужны сырые animations[], чтобы потом каждому
    // скину пристёгивать отдельно.
    const result = await SceneLoader.LoadAssetContainerAsync(
        url.substring(0, url.lastIndexOf("/") + 1),
        url.substring(url.lastIndexOf("/") + 1),
        scene,
    );
    const out = [];
    // В GLB от Mixamo каждая кость — это TransformNode (или Bone),
    // содержит свои keyframe animations. После загрузки они на
    // result.transformNodes / result.skeletons[].bones.
    const allNodes = [
        ...(result.transformNodes || []),
        ...((result.skeletons || []).flatMap(sk => sk.bones || [])),
    ];
    for (const node of allNodes) {
        if (!node.animations || node.animations.length === 0) continue;
        const cleanName = _normalizeBone(node.name);
        if (!cleanName) continue;
        out.push({ boneName: cleanName, animations: node.animations.slice() });
    }
    // Освободим геометрию (если случайно приехала — у анимаций мешей нет)
    result.dispose();
    return out;
 }
 /**
 * Загрузить базовые анимации (idle/walk/run/jump/fall) один раз.
 * Дополнительные анимации (extra + эмоции) грузятся лениво в _ensureLoaded
 * при первом обращении — это экономит трафик: юзер качает только то что
 * реально использует в игре.
 */
 export async function loadMixamoAnimations(scene) {
    if (_loadPromise) return _loadPromise;
    _cachedRawTargets = _cachedRawTargets || {};
    _loadPromise = (async () => {
        const base = _assetsBase();
        const entries = await Promise.all(
            BASE_STATES.map(async (name) => {
                try {
                    const tracks = await _loadAnimGlb(
                        scene, `${base}/character-assets/animations/${name}.glb`);
                    return [name, tracks];
                } catch (e) {
                    console.warn(`[MixamoAnimator] не загрузилась '${name}':`, e?.message || e);
                    return [name, []];
                }
            })
        );
        for (const [k, v] of entries) _cachedRawTargets[k] = v;
        // eslint-disable-next-line no-console
        console.log("[MixamoAnimator] базовые анимации загружены:",
            Object.entries(_cachedRawTargets).map(([k, v]) => `${k}=${v.length}tracks`).join(", "));
        return _cachedRawTargets;
    })();
    return _loadPromise;
 }
 /**
 * Ленивая подгрузка одной анимации по имени (если ещё не в кэше).
 * Возвращает массив tracks или null если не удалось.
 */
 async function _ensureLoaded(scene, name) {
    if (!_cachedRawTargets) _cachedRawTargets = {};
    if (_cachedRawTargets[name]) return _cachedRawTargets[name];
    const base = _assetsBase();
    try {
        const tracks = await _loadAnimGlb(
            scene, `${base}/character-assets/animations/${name}.glb`);
        _cachedRawTargets[name] = tracks;
        // eslint-disable-next-line no-console
        console.log(`[MixamoAnimator] lazy-load '${name}': ${tracks.length} tracks`);
        return tracks;
    } catch (e) {
        console.warn(`[MixamoAnimator] не удалось загрузить '${name}':`, e?.message || e);
        _cachedRawTargets[name] = [];
        return null;
    }
 }
 export class MixamoAnimator {
    constructor() {
        this.scene = null;
        this.skeleton = null;
        this.modelRoot = null;
        /** Map<state, AnimationGroup> — кастомные группы для ЭТОГО скелета */
        this._groups = new Map();
        this._currentState = null;
        this._currentGroup = null;
        this._currentEmote = null;
        this._emoteOnDone = null;
        this._blendInProgress = false;
    }
    /**
     * Пристёгивает аниматор к конкретному скелету (после загрузки модели).
     * scene — Babylon Scene, skeleton — Babylon Skeleton, modelRoot — TransformNode.
     */
    attach(scene, skeleton, modelRoot) {
        this.scene = scene;
        this.skeleton = skeleton;
        this.modelRoot = modelRoot;
        // Резолвим маппинг "clean name" → Bone (из текущего скелета).
        this._cleanToBone = new Map();
        for (const b of (skeleton.bones || [])) {
            const clean = _normalizeBone(b.name);
            if (clean && !this._cleanToBone.has(clean)) {
                this._cleanToBone.set(clean, b);
            }
        }
        // Также детектим target-property: TransformNode? linkedTransformNode?
        // Mixamo-анимации обычно нацелены на linkedTransformNode'ы (если есть),
        // потому что в glTF skin'ы делают joints через nodes, не через Bones.
        // Для каждой кости берём её _linkedTransformNode (Babylon API).
        this._cleanToTarget = new Map();
        for (const [name, bone] of this._cleanToBone) {
            const tnode = bone.getTransformNode ? bone.getTransformNode() : null;
            this._cleanToTarget.set(name, tnode || bone);
        }
        // Запомним bind-pose позиции (особенно Hips) — нужны для нормализации
        // Hips.position в jump_air/jump_land и для сброса после анимаций.
        this._restPositions = new Map();
        for (const [name, target] of this._cleanToTarget) {
            if (target && target.position) {
                this._restPositions.set(name, {
                    x: target.position.x,
                    y: target.position.y,
                    z: target.position.z,
                });
            }
        }
    }
    /** Создать (или достать из кэша) AnimationGroup для конкретного состояния. */
    _ensureGroup(state) {
        if (this._groups.has(state)) return this._groups.get(state);
        if (!_cachedRawTargets || !_cachedRawTargets[state]) return null;
        const raw = _cachedRawTargets[state];
        const group = new AnimationGroup(`mixamo_${state}`, this.scene);
        let attached = 0;
        for (const t of raw) {
            const target = this._cleanToTarget.get(t.boneName);
            if (!target) continue;
            for (const anim of t.animations) {
                // Клонируем анимацию (одна Babylon.Animation не может
                // быть в двух разных AnimationGroup одновременно).
                const cloned = anim.clone();
                // Mixamo всегда грузит Hips.position — это сдвигает
                // персонажа по сцене. В in-place анимациях должно быть
                // близко к нулю, но иногда сдвиг есть. Для базовых
                // движений (walk/run/jump) фильтруем targetProperty=position
                // у кости с именем Hips — её двигает наш PlayerController.
                if (t.boneName === "Hips" && cloned.targetProperty === "position") {
                    // 3-фазная модель прыжка:
                    //   jump_anticipate — присед перед прыжком. baseY = первый кадр
                    //     (стоячая поза → опускается ниже).
                    //   jump_air — физика поднимает _modelRoot, Hips.Y не используем.
                    //   jump_land — приземление с амортизацией. baseY = МИНИМУМ
                    //     (самая низкая точка приседа), так первый кадр будет Y > 0
                    //     (только что приземлились, ноги пружинят к bind),
                    //     середина = 0 (присед на полу), конец = выпрямление.
                    // Для всех остальных — фильтруем (физика двигает _modelRoot).
                    const PHASES = new Set([
                        'jump_anticipate', 'jump_land',
                        'jump_fwd_anticipate', 'jump_fwd_land',
                        'jump_run_anticipate', 'jump_run_land',
                    ]);
                    if (!PHASES.has(state)) {
                        continue;
                    }
                    const rest = this._restPositions?.get('Hips');
                    try {
                        const keys = cloned.getKeys();
                        if (keys && keys.length > 0 && keys[0].value) {
                            // baseY = МАКСИМУМ Y по клипу. Тогда delta = k.Y - max
                            // всегда ≤ 0 → Hips только опускается ниже bind.
                            // jump_land: персонаж приземлился (ноги на полу = bind),
                            //   потом корпус опускается = присед амортизации,
                            //   потом возвращается обратно к bind (выпрямление).
                            // jump_anticipate: то же — корпус опускается из стоячей.
                            let maxY = -Infinity;
                            for (const k of keys) {
                                const y = k.value.y || 0;
                                if (y > maxY) maxY = y;
                            }
                            const baseY = Number.isFinite(maxY) ? maxY : (keys[0].value.y || 0);
                            const newKeys = keys.map(k => ({
                                frame: k.frame,
                                value: new (k.value.constructor)(
                                    rest ? rest.x : 0,
                                    (rest ? rest.y : 0) + ((k.value.y || 0) - baseY),
                                    rest ? rest.z : 0,
                                ),
                                inTangent: k.inTangent,
                                outTangent: k.outTangent,
                                interpolation: k.interpolation,
                            }));
                            cloned.setKeys(newKeys);
                        }
                    } catch (e) { continue; }
                }
                group.addTargetedAnimation(cloned, target);
                attached++;
            }
        }
        if (attached === 0) {
            group.dispose();
            // eslint-disable-next-line no-console
            console.warn(`[MixamoAnimator] state='${state}' — 0 целей зарезолвлено, skip`);
            return null;
        }
        // Зацикливаем базовые состояния, кроме jump (он one-shot).
        // ВАЖНО: для AnimationGroup нужно ставить loopAnimation=true НА
        // САМОМ GROUP до start(). Параметр loop в start() игнорируется в
        // некоторых версиях Babylon 7.x.
        // One-shot анимации (играются один раз, не зацикливаются):
        // jump, crouch_enter, crouch_to_stand, crouch_exit + все эмоции и
        // эпизодические действия (hit, die, throw, pickup, gun_fire, gun_reload и т.д.)
        const ONE_SHOT = new Set([
            "jump", "jump_forward", "jump_backward", "jump_down",
            "jump_anticipate", "jump_land",
            "jump_fwd_anticipate", "jump_fwd_air", "jump_fwd_land",
            "jump_run_anticipate", "jump_run_air", "jump_run_land",
            "crouch_enter", "crouch_to_stand",
            "climb_to_top",
            "hit_react", "die_forward", "die_back",
            "throw_action", "pickup", "push_button", "open_door",
            "gun_fire", "gun_reload", "sword_slash",
            "kick_low", "kick_high", "punch_left",
        ]);
        // emote_* — one-shot (один жест), dance_* — лупим (танцы должны крутиться)
        const loopable = !ONE_SHOT.has(state) && !state.startsWith("emote_");
        group.loopAnimation = loopable;
        group.normalize();
        // Safety-net: если Babylon всё равно по какой-то причине отыграл
        // клип до конца И не зациклил (что бывает с короткими "still pose"
        // клипами от Mixamo вроде Crouched Idle ~0.5s) — перезапускаем
        // принудительно. Это даёт стабильно зацикленную анимацию.
        if (loopable) {
            group.onAnimationGroupEndObservable.add(() => {
                if (this._currentGroup === group && !this._currentEmote) {
                    try {
                        group.reset();
                        group.start(true, 1.0, group.from, group.to, false);
                    } catch (_) {}
                }
            });
        }
        // eslint-disable-next-line no-console
        console.log(`[MixamoAnimator] group '${state}': ${attached} tracks, loop=${loopable}, duration=${((group.to - group.from) / 60).toFixed(2)}s`);
        this._groups.set(state, group);
        return group;
    }
    /** Установить состояние с плавным кросс-фейдом 150 мс.
     *  Если анимация ещё не подгружена — стартует lazy-load, при этом
     *  setState вернётся синхронно (без ожидания) — анимация подхватится
     *  на следующем тике после успешной загрузки.
     *
     *  Anti-flicker: между переключениями требуется минимальная задержка
     *  120мс (кроме переходов в воздух/идл из приземления). Это убирает
     *  «дрожание» crouch_walk ↔ crouch_idle когда игрок едет по диагонали
     *  и одно из направлений физически дёргается между кадрами. */
    setState(state) {
        if (this._currentEmote) return; // эмоция блокирует смену состояния
        if (state === this._currentState) return;
        // Сброс Hips.position в bind-pose при выходе из jump-фаз.
        // Иначе последний keyframe анимации остаётся на Hips и idle/walk
        // подхватывает смещённую позицию → персонаж проседает.
        const JUMP_STATES = new Set([
            'jump_air', 'jump_land', 'jump_in_place', 'jump_anticipate',
            'jump_fwd_anticipate', 'jump_fwd_air', 'jump_fwd_land',
            'jump_run_anticipate', 'jump_run_air', 'jump_run_land',
        ]);
        if (JUMP_STATES.has(this._currentState) && !JUMP_STATES.has(state)
            && this._restPositions) {
            const rest = this._restPositions.get('Hips');
            const hips = this._cleanToTarget?.get('Hips');
            if (rest && hips && hips.position) {
                try {
                    hips.position.x = rest.x;
                    hips.position.y = rest.y;
                    hips.position.z = rest.z;
                } catch (_) {}
            }
        }
        const now = (typeof performance !== 'undefined' ? performance.now() : Date.now());
        // Anti-flicker debounce: не даём переключать состояние чаще чем раз в 120мс,
        // КРОМЕ переходов с/на воздушные состояния (jump/fall) — там важна скорость
        // и one-shot crouch_enter/crouch_to_stand (они короткие).
        const JUMP_VITAL = new Set([
            'jump', 'fall', 'jump_air', 'jump_land', 'jump_anticipate',
            'jump_fwd_anticipate', 'jump_fwd_air', 'jump_fwd_land',
            'jump_run_anticipate', 'jump_run_air', 'jump_run_land',
        ]);
        const isVitalSwitch = JUMP_VITAL.has(state)
            || JUMP_VITAL.has(this._currentState)
            || state === 'crouch_enter' || state === 'crouch_to_stand';
        if (!isVitalSwitch && this._lastSwitchAt && (now - this._lastSwitchAt) < 120) {
            // Запомним последний запрошенный state — если он не изменится за
            // окно debounce, тогда применим, иначе отбросим вспышку.
            this._pendingState = state;
            if (!this._debounceTimer) {
                const delay = Math.max(0, 120 - (now - this._lastSwitchAt));
                this._debounceTimer = setTimeout(() => {
                    this._debounceTimer = null;
                    const s = this._pendingState;
                    this._pendingState = null;
                    if (s && s !== this._currentState) this.setState(s);
                }, delay);
            }
            return;
        }
        this._lastSwitchAt = now;
        // Если ещё не загружено — стартуем lazy-load, но ТЕКУЩУЮ анимацию
        // НЕ останавливаем (иначе в момент Ctrl-on/off персонаж зависает
        // в bind-pose пока crouch_idle асинхронно качается).
        if (!_cachedRawTargets || !_cachedRawTargets[state]) {
            if (!this._pendingLoads) this._pendingLoads = new Set();
            if (!this._pendingLoads.has(state)) {
                this._pendingLoads.add(state);
                _ensureLoaded(this.scene, state).then(() => {
                    this._pendingLoads.delete(state);
                });
            }
            return; // подхватится при следующем setState когда tracks будут
        }
        const next = this._ensureGroup(state);
        if (!next) return;
        const prev = this._currentGroup;
        // Loop-флаг берём напрямую с group — _ensureGroup уже разрулил
        // (one-shot list + emote_* → не лупим).
        const loop = next.loopAnimation;
        // Лог переключений (только если изменилось — иначе спам)
        // eslint-disable-next-line no-console
        console.log(`[MixamoAnimator] setState: ${this._currentState || 'none'} → ${state} (loop=${loop})`);
        // Per-state speedRatio: подгоняем длительность под физику.
        // jump_fwd_air: Mixamo Jump полёт = 0.43с, физика = 0.73с
        //   → speedRatio = 0.59 (замедлить чтобы клип не зациклился).
        // jump_fwd_air: Mixamo Jump полёт 0.43с, физика 0.73с → 0.59
        // jump_run_air: Mixamo Running Jump полёт 0.52с, физика 0.73с → 0.71
        const SPEED_RATIO = {
            jump_fwd_air: 0.59,
            jump_run_air: 0.71,
        };
        const speedRatio = SPEED_RATIO[state] || 1.0;
        // Запустить новую анимацию. Babylon 7 ВНИМАНИЕ: параметр loop
        // в start() иногда игнорится — дублируем через loopAnimation
        // (выставлен в _ensureGroup).
        try {
            next.reset();
            next.start(loop, speedRatio, next.from, next.to, false);
        } catch (e) {
            try { next.play(loop); } catch (_) {}
        }
        // Кросс-фейд через weight (0→1 у новой, 1→0 у старой) за BLEND_MS.
        // Climb-состояния переключаем МГНОВЕННО (0мс) — при blend'е персонаж
        // на доли секунды виден в промежуточном развороте (старая поза + новый
        // _modelYaw), что выглядит как «дёрг разворота» при входе/выходе с лестницы.
        const CLIMB_STATES = new Set(['climb_up', 'climb_down', 'climb_to_top']);
        const BLEND_MS = (CLIMB_STATES.has(state) || CLIMB_STATES.has(this._currentState))
            ? 0 : 150;
        try { next.setWeightForAllAnimatables(0); } catch (_) {}
        // Снимаем ВСЕ предыдущие blend-observers — rapid-switching
        // (Ctrl on/off с интервалом 50ms) оставлял несколько ticker'ов.
        if (this._blendObservers && this._blendObservers.length) {
            for (const o of this._blendObservers) {
                try { this.scene.onBeforeRenderObservable.remove(o); } catch (_) {}
            }
        }
        this._blendObservers = [];
        // КРИТИЧНО: при ЛЮБОМ setState останавливаем ВСЕ остальные группы
        // кроме новой. Это убирает кейсы когда rapid-switching между
        // prev/next/третий оставляет висящую группу из позапрошлого setState
        // (и она «крутится» дальше в фоне с весом 1).
        for (const g of this._groups.values()) {
            if (g !== next) {
                // Не стопим текущую blend-исходную — она нужна для фейда.
                if (g !== prev) {
                    try { g.stop(); g.setWeightForAllAnimatables(0); } catch (_) {}
                }
            }
        }
        if (prev && prev !== next) {
            const startedAt = (typeof performance !== 'undefined' ? performance.now() : Date.now());
            const prevGroup = prev;
            const nextGroup = next;
            const obs = this.scene.onBeforeRenderObservable.add(() => {
                const nowMs = (typeof performance !== 'undefined' ? performance.now() : Date.now());
                const t = Math.min(1, (nowMs - startedAt) / BLEND_MS);
                // Если за это время _currentGroup сменилась ещё раз —
                // прекращаем blend (новый setState уже разрулил).
                if (this._currentGroup !== nextGroup) {
                    try { this.scene.onBeforeRenderObservable.remove(obs); } catch (_) {}
                    return;
                }
                try {
                    prevGroup.setWeightForAllAnimatables(1 - t);
                    nextGroup.setWeightForAllAnimatables(t);
                } catch (_) {}
                if (t >= 1) {
                    try { prevGroup.stop(); prevGroup.setWeightForAllAnimatables(0); } catch (_) {}
                    try { nextGroup.setWeightForAllAnimatables(1); } catch (_) {}
                    this.scene.onBeforeRenderObservable.remove(obs);
                }
            });
            this._blendObservers.push(obs);
        } else {
            try { next.setWeightForAllAnimatables(1); } catch (_) {}
        }
        this._currentState = state;
        this._currentGroup = next;
    }
    /** Проиграть эмоцию (one-shot), потом вернуться в idle.
     *  Если эмоция ещё не подгружена — подгружает на лету и стартует. */
    async playEmote(name, onDone) {
        const tracks = await _ensureLoaded(this.scene, name);
        if (!tracks || tracks.length === 0) {
            console.warn(`[MixamoAnimator] эмоция '${name}' не загружена`);
            if (onDone) onDone();
            return;
        }
        const group = this._ensureGroup(name);
        if (!group) { if (onDone) onDone(); return; }
        // Стоп текущего состояния
        if (this._currentGroup) {
            try { this._currentGroup.stop(); } catch (_) {}
        }
        this._currentEmote = name;
        this._emoteOnDone = onDone || null;
        const savedState = this._currentState;
        try {
            group.start(false, 1.0, group.from, group.to, false);
        } catch (e) {
            try { group.play(false); } catch (_) {}
        }
        const onEnd = () => {
            this._currentEmote = null;
            this._currentState = null;       // принудим setState заново запустить
            this.setState(savedState || "idle");
            if (this._emoteOnDone) {
                const cb = this._emoteOnDone;
                this._emoteOnDone = null;
                try { cb(); } catch (_) {}
            }
        };
        group.onAnimationGroupEndObservable.addOnce(onEnd);
    }
    /** Тихая предзагрузка анимации в кэш (БЕЗ проигрывания). Нужно чтобы
     *  при первом setState анимация уже была готова (нет дёрга от walk). */
    preload(name) {
        try { _ensureLoaded(this.scene, name); } catch (e) {}
    }
    /** Babylon сам тикает AnimationGroup, но оставим для интерфейса. */
    // eslint-disable-next-line no-unused-vars
    update(dt) { /* noop */ }
    /** Остановить и освободить все группы для этого скелета. */
    detach() {
        if (this._currentGroup) { try { this._currentGroup.stop(); } catch (_) {} }
        for (const g of this._groups.values()) {
            try { g.dispose(); } catch (_) {}
        }
        this._groups.clear();
        this._currentGroup = null;
        this._currentState = null;
        this._currentEmote = null;
        this.scene = null;
        this.skeleton = null;
        this.modelRoot = null;
    }
 }
--- a/src/engine/MultiplayerSync.js
+++ b/src/engine/MultiplayerSync.js
@ -64,7 +64,7 @@ function loadSkinManifest() {
 * @returns {Promise<{file:string, isR15:boolean, overrides:object}|null>}
 */
 async function resolveRemoteModelSource(modelType) {
-    const typeId = modelType || 'skin_bacon-hair';
+    const typeId = modelType || 'skin_y-bot';
    if (typeId.startsWith('skin_')) {
        const manifest = await loadSkinManifest();
        const entry = manifest.find((s) => s.id === typeId);
@ -713,7 +713,7 @@ export class MultiplayerSync {
            maxHp: player.maxHp ?? 100,
            isDead: !!player.isDead,
            username: player.username || sessionId,
-            modelType: player.modelType || 'skin_bacon-hair',
+            modelType: player.modelType || 'skin_y-bot',
            animState: player.animState || 'idle',
            // Если модель не успеет загрузиться, висит fallback-капсула.
            fallbackMesh: null,
--- a/src/engine/PhysicsAABB.js
+++ b/src/engine/PhysicsAABB.js
@ -1192,4 +1192,24 @@ export class PhysicsAABB {
        }
        return out;
    }
    /**
     * Найти лестницу (ladder_vertical), которой касается AABB игрока.
     * Лестницы проходимы (canCollide=false) → НЕ попадают в spatial-grid,
     * поэтому итерируем напрямую по инстансам (их на сцене единицы).
     * Возвращает data ближайшей пересекающейся лестницы или null.
     */
    getOverlappingLadder(cx, cy, cz, hw, hh, hd) {
        if (!this.primitiveManager) return null;
        let best = null, bestDist = Infinity;
        for (const data of this.primitiveManager.instances.values()) {
            if (data.type !== 'ladder_vertical') continue;
            if (data.visible === false) continue;
            if (!this._aabbIntersectsPrimitive(cx, cy, cz, hw, hh, hd, data)) continue;
            const dx = data.x - cx, dz = data.z - cz;
            const d = dx * dx + dz * dz;
            if (d < bestDist) { bestDist = d; best = data; }
        }
        return best;
    }
 }
--- a/src/engine/PlayerController.js
+++ b/src/engine/PlayerController.js
@ -28,11 +28,35 @@ import {
 import { getModelType } from './ModelTypes';
 import { R15Skeleton } from './R15Skeleton';
 import { R15Animator } from './R15Animator';
 import { MixamoAnimator, loadMixamoAnimations } from './MixamoAnimator';
 // Подфаза 3.2/3.3 RUBLOX_ACCESSORY_ATTACHMENT_PLAN.md
 import { AccessoryManager } from './AccessoryManager';
 // Цикл режимов: первое лицо → за спиной → спереди (показ персонажа лицом).
 // 'front' удобен чтобы оценить скин: камера спереди, смотрит на лицо персонажа.
 /* Mixamo-скины (новые персонажи rublox-site /character-assets/skins/).
 * 2026-06-11: эти 80 ID перенесены сюда из data/skinsCatalog.js фронта
 * чтобы плеер их распознавал и грузил по правильному пути.
 * Дефолтные: skin_x-bot (male), skin_y-bot (female/null). */
 export const MIXAMO_SKINS = new Set([
    'skin_aj', 'skin_akai', 'skin_arissa', 'skin_big-vegas',
    'skin_castle-guard-1', 'skin_castle-guard-2',
    'skin_ch01', 'skin_ch02', 'skin_ch03', 'skin_ch04', 'skin_ch07', 'skin_ch08',
    'skin_ch09', 'skin_ch10', 'skin_ch11', 'skin_ch13', 'skin_ch14', 'skin_ch15',
    'skin_ch16', 'skin_ch17', 'skin_ch18', 'skin_ch19', 'skin_ch20', 'skin_ch21',
    'skin_ch22', 'skin_ch23', 'skin_ch24', 'skin_ch29', 'skin_ch31', 'skin_ch32',
    'skin_ch33', 'skin_ch34', 'skin_ch35', 'skin_ch39', 'skin_ch40', 'skin_ch42',
    'skin_ch43', 'skin_ch44', 'skin_ch45', 'skin_ch46', 'skin_ch47', 'skin_ch48',
    'skin_claire', 'skin_demon', 'skin_ely', 'skin_erika-archer', 'skin_erika-archer-bow',
    'skin_eve', 'skin_exo-gray', 'skin_exo-red', 'skin_ganfaul', 'skin_heraklios',
    'skin_kachujin', 'skin_kaya', 'skin_knight', 'skin_lola', 'skin_maria',
    'skin_maria-wprop', 'skin_maw', 'skin_medea', 'skin_mutant', 'skin_nightshade',
    'skin_paladin', 'skin_passive-marker-man', 'skin_peasant-girl', 'skin_peasant-man',
    'skin_prisoner', 'skin_pumpkinhulk', 'skin_skeleton-zombie', 'skin_sporty-granny',
    'skin_survivor', 'skin_swat', 'skin_ty', 'skin_uriel', 'skin_vampire',
    'skin_war-zombie', 'skin_warrok', 'skin_white-clown', 'skin_x-bot', 'skin_y-bot',
 ]);
 const CAMERA_MODES = ['third', 'first', 'front'];
 // Для режима 'sideview' (Кубикон Dash):
 //   - камера фиксирована сбоку (смотрит на +Z с расстояния SIDEVIEW_DIST по -Z)
@ -83,6 +107,11 @@ export class PlayerController {
        this._waveMode = false;        // GD-гейммод Wave: всегда движение под ±45° (Space зажат — вверх, отпущен — вниз)
        this._robotMode = false;       // GD-гейммод Robot: высота прыжка = длительность удержания Space (variable-jump)
        this._robotBoostLeft = 0;      // оставшееся время boost-фазы (с)
        // Лестница (ladder_vertical): касание + W/S → ladder-mode (гравитация
        // отключена, W/S = вверх/вниз, Space = отпрыг).
        this._ladderMode = false;
        this._ladderData = null;
        this.CLIMB_SPEED = 2.5;        // скорость лазания вверх/вниз (м/с)
        // Кубикон Dash: если > 0 — игрок САМ движется по +X со скоростью X м/с.
        // Ввод (WASD/тач-джойстик) игнорируется в _tick. Прыжок остаётся.
        this._autoRunSpeed = 0;
@ -168,8 +197,8 @@ export class PlayerController {
        this._stepUpDecay = 4.5;
        // Модель игрока (грузится в start)
-        // Дефолт — R15-скин bacon-hair (классический Roblox-вид).
+        // 2026-06-13: дефолт сменён на skin_y-bot (Mixamo Y-Bot).
-        this._modelTypeId = 'skin_bacon-hair';
+        this._modelTypeId = 'skin_y-bot';
        this._modelRoot = null;
        this._modelMeshes = [];
        // Кубикон Dash: скрипт через game.player.setSkinVisible(false) выставляет
@ -191,6 +220,7 @@ export class PlayerController {
        this._isR15 = false;          // флаг: загружен валидный R15-скелет
        this._r15Skeleton = null;     // R15Skeleton — резолвер костей
        this._r15Animator = null;     // R15Animator — процедурные анимации
        this._mixamoAnimator = null;  // MixamoAnimator — Mixamo-скины
        this._skinManifest = null;    // кеш skins_manifest.json
        this._skinOverrides = {};     // overrides текущего скина
@ -341,6 +371,8 @@ export class PlayerController {
        this._r15Skeleton = null;
        this._r15Animator = null;
        this._isR15 = false;
        try { if (this._mixamoAnimator) this._mixamoAnimator.detach(); } catch (e) {}
        this._mixamoAnimator = null;
        this._modelKind = 'r15';
        this._modelHipHeight = null;
        this._nonHumanoidBox = null;
@ -786,19 +818,32 @@ export class PlayerController {
            return null;
        }
        if (typeId.startsWith('skin_')) {
            // 2026-06-11: палитра скинов Рублокса заменена на 80 Mixamo.
            // Mixamo-скины: /character-assets/skins/<id>.glb (на rublox-site).
            // Legacy-скины (skin_bacon-hair / skin_sigma-labubu / skin_cop / ...)
            // ещё могут приходить из БД пока feature-flag в storys выключен —
            // их грузим из старого /kubikon-assets/characters/<id>/body.glb
            // (R15-скелет). После заливки 80 GLB на rublox.pro и включения
            // RUBLOX_NEW_SKINS_AVAILABLE=true legacy-ветка перестанет
            // срабатывать (бэк начнёт отдавать только новые типы).
            if (MIXAMO_SKINS.has(typeId)) {
                const base = (typeof window !== 'undefined'
                    && window.location.hostname === 'localhost')
                    ? 'http://localhost:3000'
                    : 'https://rublox.pro';
                return {
                    file: `${base}/character-assets/skins/${typeId}.glb?v=20260614`,
                    isR15: false,
                    kind: 'non-humanoid-rigged',  // Mixamo-rig, не R15
                    overrides: {},
                    isMixamo: true,
                };
            }
            // Legacy R15-скин — через старый manifest.
            const manifest = await this._loadSkinManifest();
            const entry = manifest.find((s) => s.id === typeId);
            if (entry) {
                // kind определяет систему анимации:
                //   'r15'                 → R15-скелет (как раньше)
                //   'non-humanoid-mesh'   → single-mesh, процедурное покачивание
                //   'non-humanoid-rigged' → свой скелет + встроенные AnimationGroup
                // Отсутствие kind = 'r15' (обратная совместимость со старым манифестом).
                const kind = entry.kind || 'r15';
                // absolute_file=true (источник /rublox/avatars) — file уже
                // полный URL (legacy /kubikon-assets/... или дизайнерский
                // /api-storys/...). Без флага — это легаси-формат
                // skins_manifest.json без префикса.
                const file = entry.absolute_file
                    ? entry.file
                    : '/kubikon-assets/' + entry.file;
@ -812,7 +857,7 @@ export class PlayerController {
                    rotationYOffset: Number.isFinite(entry.rotationYOffset) ? entry.rotationYOffset : 0,
                };
            }
-            // нет в манифесте — пробуем прямой путь
+            // нет ни в Mixamo, ни в manifest — пробуем прямой legacy-путь
            return {
                file: `/kubikon-assets/characters/${typeId}/body.glb`,
                isR15: true,
@ -1167,8 +1212,59 @@ export class PlayerController {
            // R15-скины не содержат AnimationGroups (анимируются процедурно
            // через R15Animator в _tick). Kenney-модели — наоборот, имеют
            // встроенные AnimationGroups (idle/walk/sprint/jump).
            // Mixamo-скины (kind=non-humanoid-rigged) — анимируются через
            // MixamoAnimator: 5 базовых анимаций грузятся отдельными GLB
            // из /character-assets/animations/ и ретаргетятся на скелет.
            this._animations = {};
-            if (!this._isR15) {
+            this._mixamoAnimator = null;
            if (source.isMixamo || source.kind === 'non-humanoid-rigged') {
                // Найдём скелет Mixamo-модели (отдельно от R15-ветки —
                // та валидацию не прошла, скелет другого формата).
                let mixSk = (inst.skeletons && inst.skeletons[0]) || null;
                if (!mixSk && container.skeletons && container.skeletons.length > 0) {
                    mixSk = container.skeletons[0];
                }
                if (!mixSk) {
                    const meshWithSkel = root.getChildMeshes(false).find((m) => m.skeleton);
                    if (meshWithSkel) mixSk = meshWithSkel.skeleton;
                }
                if (mixSk) {
                    try {
                        // Грузим базовые анимации (singleton-кэш — после первого
                        // скина следующие переключаются мгновенно).
                        const animator = new MixamoAnimator();
                        loadMixamoAnimations(this.scene)
                            .then(() => {
                                animator.attach(this.scene, mixSk, root);
                                animator.setState('idle');
                                this._mixamoAnimator = animator;
                                // Предзагрузим climb-анимации заранее (тихо),
                                // чтобы при первом касании лестницы не было кадра
                                // walk с climb-поворотом (дёрг на 180°).
                                try {
                                    animator.preload('climb_up');
                                    animator.preload('climb_down');
                                    animator.preload('climb_to_top');
                                } catch (e) {}
                                // Глобально для отладки/скриптов:
                                //   window.__mixamo.playEmote('dance_hiphop')
                                try { window.__mixamo = animator; } catch (e) {}
                                // eslint-disable-next-line no-console
                                console.log('[PlayerController] MixamoAnimator готов, скелет=' + mixSk.bones.length + ' bones');
                            })
                            .catch((e) => {
                                // eslint-disable-next-line no-console
                                console.warn('[PlayerController] MixamoAnimator не загрузился:', e);
                            });
                    } catch (e) {
                        // eslint-disable-next-line no-console
                        console.warn('[PlayerController] MixamoAnimator init fail:', e);
                    }
                } else {
                    // eslint-disable-next-line no-console
                    console.warn('[PlayerController] Mixamo-скин', this._modelTypeId, '— скелет не найден');
                }
            } else if (!this._isR15) {
                const groups = inst.animationGroups || [];
                for (const g of groups) {
                    const name = (g.name || '').toLowerCase();
@ -1625,6 +1721,9 @@ export class PlayerController {
        this._r15Animator = null;
        this._r15Skeleton = null;
        this._isR15 = false;
        // Сброс MixamoAnimator
        try { if (this._mixamoAnimator) this._mixamoAnimator.detach(); } catch (e) {}
        this._mixamoAnimator = null;
        // Удаляем модель
        if (this._modelRoot) {
@ -2535,10 +2634,26 @@ export class PlayerController {
        const onKeyDown = (e) => {
            if (!this._active) return;
            if (isTypingTarget(e.target)) return;
-            // Задача 04: Esc в Play — приоритет закрытие модала через _onExitRequest
+            // Меню в игре (Roblox-style — Участники / Настройки / etc).
-            // (там стоит проверка modalManager.isOpen). Без явного перехвата Esc
+            //
-            // в third (без pointer-lock) сразу выходил из Play.
+            // ПРАВИЛО (2026-06-14):
-            if (e.code === 'Escape') {
+            //   • НЕ в fullscreen — Esc открывает меню (классика)
            //   • В fullscreen     — Esc отдаётся БРАУЗЕРУ (выход из FS, hardcoded),
            //                        а меню открывается на Tab (как в CS/BF)
            //
            // Это компромисс: в fullscreen нельзя перехватить Esc — браузер
            // принудительно выкидывает в обычный режим. Поэтому добавили
            // вторую клавишу. Tab безопасен (не блокирует UI-фокус
            // потому что мы делаем preventDefault).
            const isFs = !!(typeof document !== 'undefined' && document.fullscreenElement);
            if (e.code === 'Escape' && !isFs) {
                if (this._onExitRequest) {
                    this._onExitRequest();
                    return;
                }
            }
            if (e.code === 'Tab' && isFs) {
                e.preventDefault();
                if (this._onExitRequest) {
                    this._onExitRequest();
                    return;
@ -2654,18 +2769,30 @@ export class PlayerController {
            const dH = this.HALF_H_CROUCH - this.HALF_H;
            this.HALF_H = this.HALF_H_CROUCH;
            if (this._pos) this._pos.y += dH;
            // Помечаем: при следующем _tick mixamo-ветка проиграет
            // one-shot crouch_enter (движение присеста) ПЕРЕД зацикленным
            // crouch_idle. Без этого визуально нет "присеста" — персонаж
            // мгновенно оказывается в позе.
            this._crouchEnterPending = true;
            this._crouchTransitionUntil = Date.now() + 600; // длительность анимации Standing→Crouch ~0.6s
        } else if (!wantCrouch && this._crouching && !this._scriptForcedCrouch) {
            this._crouching = false;
            const dH = this.HALF_H_NORMAL - this.HALF_H;
            this.HALF_H = this.HALF_H_NORMAL;
            if (this._pos) this._pos.y += dH;
            // Анимация выхода — crouch_to_stand
            this._crouchExitPending = true;
            this._crouchTransitionUntil = Date.now() + 600;
        }
        // === Горизонтальное движение ===
        const forward = new Vector3(Math.sin(this._yaw), 0, Math.cos(this._yaw));
        const right   = new Vector3(Math.cos(this._yaw), 0, -Math.sin(this._yaw));
-        const isSprinting = this._shift;
+        // Crouch имеет ПРИОРИТЕТ над sprint: если Ctrl зажат — Shift игнорится.
-        const speedMult = isSprinting ? this.SPRINT_MULT : 1;
+        // Скорость в crouch = 0.45 от walk (медленный шаг на корточках).
        const isSprinting = this._shift && !this._crouching;
        const crouchMult = this._crouching ? 0.45 : 1;
        const speedMult = (isSprinting ? this.SPRINT_MULT : 1) * crouchMult;
        const speed = this.WALK_SPEED * speedMult * (this._speedMul || 1) * dt;
        let moveX = 0, moveZ = 0;
@ -2749,8 +2876,154 @@ export class PlayerController {
            moveZ *= 0.5;
        }
        // === Лестница (ladder_vertical) ===
        // Детект касания лестницы. В воде/машине/GD-режиме лестница отключена.
        let ladder = null;
        if (!inWater && !inGdMode && this.physics?.getOverlappingLadder) {
            ladder = this.physics.getOverlappingLadder(
                this._pos.x, this._pos.y, this._pos.z,
                this.HALF_W, this.HALF_H, this.HALF_D
            );
        }
        // Предзагрузка climb-анимаций при касании лестницы (ДО лазания),
        // чтобы при входе в ladder-mode climb_up уже был в кэше. Без этого
        // первый кадр играет walk с climb-поворотом → персонаж «дёргается»
        // на 180° пока climb_up асинхронно подгружается.
        if (ladder && this._mixamoAnimator && !this._climbPreloaded) {
            this._climbPreloaded = true;
            try {
                this._mixamoAnimator.preload('climb_up');
                this._mixamoAnimator.preload('climb_down');
                this._mixamoAnimator.preload('climb_to_top');
            } catch (e) {}
        }
        const wantUp   = c.has('KeyW') || c.has('ArrowUp');
        const wantDown = c.has('KeyS') || c.has('ArrowDown');
        // Фаза climb_to_top — вылезание на площадку (4с). Блокирует всё:
        // управление, физику, обычный ladder-mode. Игрок плавно перемещается
        // из _climbTopStart в _climbTopEnd (lerp), анимация climb_to_top играет.
        if (this._climbingTop) {
            const total = 4000;
            const left = this._climbingTopUntil - Date.now();
            const t = Math.max(0, Math.min(1, 1 - left / total));
            const a = this._climbTopStart, b = this._climbTopEnd;
            if (a && b) {
                this._pos.x = a.x + (b.x - a.x) * t;
                this._pos.y = a.y + (b.y - a.y) * t;
                this._pos.z = a.z + (b.z - a.z) * t;
            }
            this._vy = 0;
            if (left <= 0) {
                // Завершили вылезание — выходим в обычный режим.
                this._climbingTop = false;
                this._ladderMode = false;
                this._ladderData = null;
                this._climbTopStart = null;
                this._climbTopEnd = null;
            }
            // Пропускаем остальную ladder/движение логику в этом кадре.
            // Но позволяем анимационной ветке проиграть climb_to_top.
        }
        // Вход в ladder-mode: касаемся лестницы И жмём вверх/вниз.
        if (!this._climbingTop && ladder && !this._ladderMode && (wantUp || wantDown)) {
            this._ladderMode = true;
            this._ladderData = ladder;
            this._vy = 0;
            // Прижать игрока к плоскости лестницы и повернуть лицом к ней.
            // Лестница плоская: её фронт — вдоль локальной оси -Z, повёрнутой
            // на rotationY. Нормаль фронта = (sin(rY), 0, cos(rY)).
            const rY = (ladder.rotationY || 0) * Math.PI / 180;
            const nx = Math.sin(rY);
            const nz = Math.cos(rY);
            // Игрок стоит ПЕРЕД лестницей: позиция = центр лестницы по XZ
            // + нормаль * (полглубины лестницы + полширины игрока).
            const standOff = (ladder.sz || 0.25) / 2 + this.HALF_D + 0.05;
            this._pos.x = ladder.x + nx * standOff;
            this._pos.z = ladder.z + nz * standOff;
            // Повернуть лицом К лестнице (смотрит против нормали).
            // climb_up-клип сам разворачивает Hips на 180°, поэтому модель
            // доворачиваем на +π, чтобы персонаж смотрел на перекладины.
            const faceYaw = Math.atan2(-nx, -nz);
            this._yaw = faceYaw;                 // камера смотрит на лестницу
            this._modelYaw = faceYaw + Math.PI;  // +180° компенсация анимации
            this._ladderMoving = null;     // сброс — climb-анимация стартует заново
        }
        // Пока в ladder-mode: обновляем ссылку на лестницу если ещё касаемся.
        // (НЕ во время climb_to_top — там своя логика перемещения.)
        if (this._ladderMode && !this._climbingTop) {
            if (ladder) this._ladderData = ladder;
            const ld = this._ladderData;
            // Верх лестницы (мировая координата). Поднялись выше — выходим наверх.
            const ladderTop = ld ? (ld.y + (ld.sy || 0) / 2) : Infinity;
            // Гистерезис выхода: НЕ выходим по мгновенному !ladder (детект
            // нестабилен на грани AABB → мигание climb↔walk каждый кадр).
            // Выходим только если игрок РЕАЛЬНО отошёл по XZ от сохранённой
            // лестницы (> половины ширины + запас).
            let farFromLadder = false;
            if (ld) {
                const dx = this._pos.x - ld.x;
                const dz = this._pos.z - ld.z;
                const distXZ = Math.hypot(dx, dz);
                const exitDist = Math.max(ld.sx || 1, ld.sz || 0.25) / 2 + this.HALF_D + 0.6;
                farFromLadder = distXZ > exitDist;
            } else {
                farFromLadder = true;
            }
            // Space → отпрыг назад + выход.
            if (c.has('Space')) {
                this._ladderMode = false;
                this._ladderData = null;
                this._vy = 5;
                this._jumpHeld = true;
            } else if (farFromLadder) {
                // Реально отошли от лестницы — выходим (гравитация включится).
                this._ladderMode = false;
                this._ladderData = null;
            } else {
                // Лазание: гравитация отключена, A/D заблокированы.
                // Вертикальное движение задаём через _vy (climb-скорость),
                // чтобы moveAABB обработал коллизию корректно. Прямое
                // _pos.y += не годилось: персонаж стоит на земле, и moveAABB
                // снапил его обратно (онГраунд держал внизу).
                moveX = 0;
                moveZ = 0;
                if (wantUp)        this._vy = this.CLIMB_SPEED;
                else if (wantDown) this._vy = -this.CLIMB_SPEED;
                else               this._vy = 0;
                // Достигли верха лестницы И лезем вверх → запускаем переход
                // climb_to_top (вылезание на площадку, 4с one-shot). Управление
                // блокируется, физика замораживается, в конце игрок ставится
                // на площадку над лестницей.
                if (this._pos.y + this.HALF_H > ladderTop - 0.3 && wantUp
                    && !this._climbingTop) {
                    this._climbingTop = true;
                    this._climbingTopUntil = Date.now() + 4000;
                    this._vy = 0;
                    // Куда вылезти: вперёд (по нормали от лестницы, внутрь
                    // площадки) + на верх лестницы.
                    const ldd = this._ladderData;
                    const rY = (ldd?.rotationY || 0) * Math.PI / 180;
                    // Нормаль фронта (откуда лез) — игрок перед лестницей.
                    // Площадка — за лестницей (противоположная сторона).
                    const fnx = Math.sin(rY), fnz = Math.cos(rY);
                    const fwd = (ldd?.sz || 0.25) / 2 + this.HALF_D + 0.4;
                    this._climbTopStart = { x: this._pos.x, y: this._pos.y, z: this._pos.z };
                    this._climbTopEnd = {
                        x: ldd.x - fnx * fwd,           // на другую сторону лестницы
                        y: ladderTop + this.HALF_H,     // на верх
                        z: ldd.z - fnz * fwd,
                    };
                }
            }
        }
        // === Вертикальное ===
-        if (inWater) {
+        if (this._ladderMode) {
            // На лестнице гравитация НЕ применяется — _vy уже выставлен
            // (=CLIMB_SPEED вверх / -CLIMB_SPEED вниз / 0 на месте) выше,
            // moveAABB применит его с коллизией.
        } else if (inWater) {
            // Плавание: лёгкая гравитация + плавучесть к поверхности
            const buoyancy = submerged ? 6 : 0;
            const swimGravity = -3;
@ -2834,7 +3107,12 @@ export class PlayerController {
        // PERF-METRICS: замер физики игрока
        const _pt0 = performance.now();
-        const result = this.physics.moveAABB(
+        // Во время climb_to_top физику пропускаем — _pos двигается lerp'ом
        // вручную (вылезание на площадку), коллизия не нужна.
        const result = this._climbingTop
            ? { x: this._pos.x, y: this._pos.y, z: this._pos.z,
                onGround: false, hitY: false, surfaceFollowed: false }
            : this.physics.moveAABB(
                this._pos, this.HALF_W, this.HALF_H, this.HALF_D,
                moveX, this._vy * dt, moveZ
            );
@ -2978,17 +3256,44 @@ export class PlayerController {
        } else
        if (canJump && c.has('Space') && !inWater && !this._shipMode && !this._ufoMode) {
            if (!this._jumpHeld) {
-                // Robot — стартовый импульс полный (как куб) для тапа достаточный,
+                // 3-фазная модель прыжка.
-                // boost-фаза 0.45с удлиняет подъём при удержании Space.
+                // _jumpKind определяется по нажатым клавишам в момент Space:
-                this._vy = this.JUMP_VELOCITY * (this._jumpPowerMul || 1) * gDir;
+                //   in_place — нет WASD (анимация Mixamo Jumping)
-                this._playJumpSound();
+                //   forward — есть WASD (анимация Mixamo Jump = прыжок вперёд)
                const cc = this._codes;
                const wasdHeld = cc && (cc.has('KeyW') || cc.has('KeyS')
                    || cc.has('KeyA') || cc.has('KeyD')
                    || cc.has('ArrowUp') || cc.has('ArrowDown')
                    || cc.has('ArrowLeft') || cc.has('ArrowRight'));
                //   in_place — нет WASD
                //   forward  — WASD без Shift (Mixamo Jump)
                //   run      — WASD + Shift (Mixamo Running Jump)
                const sprinting = this._shift && !this._crouching;
                if (!wasdHeld) this._jumpKind = 'in_place';
                else if (sprinting) this._jumpKind = 'run';
                else this._jumpKind = 'forward';
                // anticipate-фаза разной длительности.
                const antDuration = this._jumpKind === 'in_place' ? 375
                    : this._jumpKind === 'run' ? 125 : 170;
                this._jumpHeld = true;
                this._coyoteLeft = 0;
                this._jumpAnticipateUntil = Date.now() + antDuration;
                this._jumpPendingImpulse = true;
                // Robot: запускаем boost-фазу на 0.45с
                if (this._robotMode) {
                    this._robotBoostLeft = 0.45;
                }
            }
        }
        // Запускаем физический прыжок ровно в конце anticipate-фазы.
        if (this._jumpPendingImpulse
            && this._jumpAnticipateUntil
            && Date.now() >= this._jumpAnticipateUntil
            && !inWater && !this._shipMode && !this._ufoMode) {
            this._vy = this.JUMP_VELOCITY * (this._jumpPowerMul || 1) * gDir;
            this._playJumpSound();
            this._jumpPendingImpulse = false;
            // _jumpAnticipateUntil оставляем для анимационной ветки
        } else if (this._shipMode && c.has('Space')) {
            this._jumpHeld = true;
        } else if (this._ufoMode && c.has('Space') && !inWater) {
@ -3088,17 +3393,46 @@ export class PlayerController {
            const fwdShift = inWater ? bodyLen * tiltFrac : 0;
            const fx = Math.sin(this._modelYaw);
            const fz = Math.cos(this._modelYaw);
            // Crouch-смещение: разные Mixamo-клипы имеют разный hip-baseline.
            //   crouch_idle (Crouching Idle)        — hip ПРИПОДНЯТ (~0.35м над землёй)
            //   crouch_walk (Sneak Walk)            — hip нормальный, ноги стандартные
            //   crouch_enter/crouch_to_stand        — переход, плавно меняется
            // Поэтому drop зависит от текущего проигрываемого state, не от _crouching.
            let crouchYDrop = 0;
            if (this._crouching && this._mixamoAnimator) {
                const ms = this._mixamoAnimator._currentState;
                if (ms === 'crouch_idle') crouchYDrop = 0.45;
                else if (ms === 'crouch_walk') crouchYDrop = 0.25;
                else if (ms === 'crouch_enter' || ms === 'crouch_to_stand') crouchYDrop = 0.30;
                else crouchYDrop = 0.30;
            }
            this._modelRoot.position.set(
                this._pos.x + fx * fwdShift,
-                this._pos.y - this.HALF_H + yLift - this._stepUpVisualOffset,
+                this._pos.y - this.HALF_H + yLift - this._stepUpVisualOffset - crouchYDrop,
                this._pos.z + fz * fwdShift
            );
            // Поворот модели:
            //  - на лестнице: лицом К лестнице, yaw зафиксирован при входе.
            //  - на суше: направление РЕАЛЬНОГО движения (как было).
            //  - в воде: направление КАМЕРЫ (yaw игрока). Стрейф A/D просто
            //    двигает тело вбок без вращения, как на суше при first-person.
-            if (inWater) {
+            if (this._climbingTop) {
                // climb_to_top: модель смотрит В сторону площадки (куда вылазит).
                // Эта анимация имеет другую ориентацию Hips чем climb_up,
                // поэтому БЕЗ +π компенсации — иначе развёрнута на 180°.
                if (this._climbTopStart && this._climbTopEnd) {
                    const dx = this._climbTopEnd.x - this._climbTopStart.x;
                    const dz = this._climbTopEnd.z - this._climbTopStart.z;
                    if (Math.abs(dx) > 0.001 || Math.abs(dz) > 0.001) {
                        this._modelYaw = Math.atan2(dx, dz);
                    }
                }
            } else if (this._ladderMode) {
                // _modelYaw уже выставлен при входе в ladder-mode (лицом к лестнице).
                // Анимация climb_up даёт ~180° поворот Hips → персонаж лицом к
                // перекладинам. Ничего не доворачиваем.
            } else if (inWater) {
                const targetYaw = this._yaw;
                let diff = targetYaw - this._modelYaw;
                while (diff > Math.PI)  diff -= Math.PI * 2;
@ -3193,6 +3527,136 @@ export class PlayerController {
            return;
        }
        // Mixamo-скин: AnimationGroup для каждого состояния, грузятся отдельно
        // из /character-assets/animations/*.glb. Состояния:
        //   idle/walk/run/jump/fall — базовые
        //   crouch_idle/crouch_walk — присед (Ctrl)
        // sprint → run. crouch имеет приоритет над sprint.
        if (this._mixamoAnimator) {
            let mState;
            const now = Date.now();
            // climb_to_top — вылезание на площадку (приоритет над всем).
            if (this._climbingTop) {
                this._mixamoAnimator.setState('climb_to_top');
                return;
            }
            // Лазание по лестнице имеет приоритет над всеми анимациями.
            //   climb_up — движется вверх (W), climb_down — вниз (S),
            //   на месте на лестнице — анимация продолжает играть циклично
            //   (НЕ паузим: g.pause() останавливал обновление скелета →
            //   bounding box не обновлялся → frustum culling прятал скин).
            if (this._ladderMode) {
                const climbUp = this._codes.has('KeyW') || this._codes.has('ArrowUp');
                const climbDown = this._codes.has('KeyS') || this._codes.has('ArrowDown');
                const moving = climbUp || climbDown;
                // Меняем state ТОЛЬКО при реальном движении. На месте держим
                // текущую анимацию (не дёргаем setState — это убирает мигание
                // climb_up↔climb_down и исчезание скина).
                if (climbUp) this._mixamoAnimator.setState('climb_up');
                else if (climbDown) this._mixamoAnimator.setState('climb_down');
                // play/pause трогаем ТОЛЬКО при смене режима движения (как в jump).
                if (moving !== this._ladderMoving) {
                    this._ladderMoving = moving;
                    try {
                        const g = this._mixamoAnimator._currentGroup;
                        if (g) {
                            if (moving) g.play(true);  // возобновить (снять паузу)
                            else g.pause();            // заморозить позу
                        }
                    } catch (e) {}
                }
                return;
            }
            const inCrouchTransition = this._crouchTransitionUntil
                && now < this._crouchTransitionUntil;
            // 3-фазная анимация прыжка. Выбираем семейство фаз по _jumpKind:
            //   in_place: jump_*           (Mixamo Jumping)
            //   forward:  jump_fwd_*       (Mixamo Jump, прыжок с шага)
            //   run:      jump_run_*       (Mixamo Running Jump, прыжок с бега)
            const jk = this._jumpKind;
            const isAirborneJump = jk === 'forward' || jk === 'run';
            let stAnticipate, stAir, stLand, landDuration;
            if (jk === 'run') {
                stAnticipate = 'jump_run_anticipate';
                stAir = 'jump_run_air';
                stLand = 'jump_run_land';
                landDuration = 175;
            } else if (jk === 'forward') {
                stAnticipate = 'jump_fwd_anticipate';
                stAir = 'jump_fwd_air';
                stLand = 'jump_fwd_land';
                landDuration = 142;
            } else {
                stAnticipate = 'jump_anticipate';
                stAir = 'jump_air';
                stLand = 'jump_land';
                landDuration = 570;
            }
            const inAnticipate = this._jumpAnticipateUntil
                && now < this._jumpAnticipateUntil
                && this._jumpPendingImpulse;
            const inJumpLand = this._jumpLandUntil && now < this._jumpLandUntil;
            // Coyote-фильтр для микро-полётов на ступеньках. При спуске по
            // лестнице из блоков персонаж 30-700мс физически в воздухе, и
            // jump_air мигает между шагами walk. Критерий — ВЫСОТА падения
            // от последней наземной позиции (а не время — полёт может быть
            // длинным при спуске лицом к камере). Опустился <1.3 блока И не
            // прыгал → ступенька, играем walk/run.
            if (result.onGround) {
                this._lastGroundY = this._pos.y;
            }
            const dropFromGround = (this._lastGroundY != null)
                ? (this._lastGroundY - this._pos.y) : Infinity;
            const microAir = !result.onGround
                && !this._jumpHeld           // не прыжок со Space
                && !this._wasAirborne        // не продолжение реального прыжка
                && dropFromGround < 1.3      // опустился меньше 1.3 блока
                && this._vy < 4;             // не подлетает вверх (степ-ап импульс)
            if (inAnticipate) {
                mState = stAnticipate;
            } else if (microAir) {
                // Микро-полёт между ступеньками — наземная анимация.
                mState = this._crouching
                    ? (isMoving ? 'crouch_walk' : 'crouch_idle')
                    : (isMoving ? (isSprinting ? 'run' : 'walk') : 'idle');
            } else if (!result.onGround) {
                mState = stAir;
                this._wasAirborne = true;
                this._crouchEnterPending = false;
                this._crouchExitPending = false;
                this._crouchTransitionUntil = 0;
                this._jumpAnticipateUntil = 0;
            } else if (this._wasAirborne) {
                this._jumpLandUntil = now + landDuration;
                this._wasAirborne = false;
                mState = stLand;
            } else if (inJumpLand) {
                // Для forward — доигрываем land даже при движении
                // (там короткая фаза 142мс)
                if (isAirborneJump || !isMoving) mState = stLand;
            } else if (this._crouchEnterPending && inCrouchTransition && !isMoving) {
                mState = 'crouch_enter';
            } else if (this._crouchExitPending && inCrouchTransition && !isMoving) {
                mState = 'crouch_to_stand';
            } else if (this._crouching) {
                this._crouchEnterPending = false;
                this._crouchExitPending = false;
                mState = isMoving ? 'crouch_walk' : 'crouch_idle';
            } else if (inWater) {
                mState = isMoving ? 'walk' : 'idle';
            } else if (isMoving) {
                this._crouchExitPending = false;
                this._crouchTransitionUntil = 0;
                this._jumpLandUntil = 0; // прерываем jump_land если пошли
                mState = isSprinting ? 'run' : 'walk';
            } else {
                this._crouchExitPending = false;
                mState = 'idle';
            }
            this._mixamoAnimator.setState(mState);
            return;
        }
        // R15-скин: процедурный аниматор (нет glTF AnimationGroups).
        // Состояния: idle/walk/run/jump/fall. sprint → run.
        if (this._isR15 && this._r15Animator) {
--- a/src/engine/PrimitiveManager.js
+++ b/src/engine/PrimitiveManager.js
@ -38,6 +38,11 @@ const STUDS_DIFFUSE_URL = '/kubikon-assets/materials/studs_v4_diffuse.png';
 const STUDS_NORMAL_URL  = '/kubikon-assets/materials/studs_v4_normal.png';
 const STUD_UNIT = 1;
 const STUDS_GRID = 4;
 // Вертикальный шаг между ступеньками лестницы (юниты). Полная высота
 // лестницы = stepCount * LADDER_STEP_SPACING.
 export const LADDER_STEP_SPACING = 0.45;
 const _studsTexCache = new WeakMap();
 function _getStudsTextures(scene) {
    let c = _studsTexCache.get(scene);
@ -114,8 +119,15 @@ export class PrimitiveManager {
            id = this._nextId++;
        }
        const sx = opts.sx ?? typeDef.defaultScale.x;
-        const sy = opts.sy ?? typeDef.defaultScale.y;
+        let sy = opts.sy ?? typeDef.defaultScale.y;
        const sz = opts.sz ?? typeDef.defaultScale.z;
        // Лестница: высота ДЕРИВИРУЕТСЯ из stepCount (а не из sy) — даёт
        // корректный AABB для детекта касания и совпадает с геометрией меша.
        const isLadder = typeDef.id === 'ladder_vertical';
        const stepCount = isLadder
            ? Math.max(2, Math.min(40, Math.round(opts.stepCount != null ? opts.stepCount : 8)))
            : undefined;
        if (isLadder) sy = stepCount * LADDER_STEP_SPACING;
        const color = opts.color ?? typeDef.defaultColor;
        // GD-сущности (порталы/шипы/финиш/монеты) — neon (светятся) и без коллизии физики.
        // Логику касания обрабатывает GdPortalManager/GdLevelManager по дистанции.
@ -126,8 +138,10 @@ export class PrimitiveManager {
        const material = opts.material ?? (isGlowingGd ? 'neon' : 'matte');
        // studDensity — плотность кружков studs (1=стандарт, >1 мельче/чаще).
        const studDensity = Number.isFinite(opts.studDensity) ? opts.studDensity : 1;
-        // canCollide: для всех GD-сущностей и шипов — false (игрок проходит сквозь, логика по дистанции)
+        // canCollide: для всех GD-сущностей и шипов — false (игрок проходит сквозь, логика по дистанции).
-        const canCollide = opts.canCollide !== false && !isGdKind && !isGdSpike;
+        // Лестница — тоже проходима (canCollide=false), чтобы игрок мог войти в её
        // объём и лезть (ladder-mode в PlayerController по детекту касания).
        const canCollide = opts.canCollide !== false && !isGdKind && !isGdSpike && !isLadder;
        const visible = opts.visible !== false;
        const anchored = opts.anchored !== false;          // по умолчанию заякорен
        // Масса по умолчанию = объём (sx*sy*sz), округлённый до 2 знаков.
@ -143,7 +157,11 @@ export class PrimitiveManager {
        const rotationY = opts.rotationY ?? 0;
        const rotationZ = opts.rotationZ ?? 0;
        // Передаём stepCount в builder через временное поле (читается в
        // _buildLadderMesh внутри _createMeshForType).
        this._ladderStepCount = stepCount;
        const mesh = this._createMeshForType(typeDef, id, sx, sy, sz, material, studDensity);
        this._ladderStepCount = undefined;
        mesh.position = new Vector3(x, y, z);
        mesh.rotation = new Vector3(rotationX, rotationY, rotationZ);
        mesh.isPickable = true;
@ -169,6 +187,8 @@ export class PrimitiveManager {
            rotationX, rotationY, rotationZ,
            color, material, canCollide, visible, anchored, mass,
            textureAsset, studDensity,
            // Лестница: число ступенек (высота). undefined для прочих.
            ...(isLadder ? { stepCount } : {}),
            // locked — объект защищён от выделения/перемещения в редакторе
            // (Фаза 5.11). На геймплей не влияет.
            locked: opts.locked === true,
@ -305,6 +325,10 @@ export class PrimitiveManager {
                return this._buildWedgeMesh(name, sx, sy, sz);
            case 'cornerwedge':
                return this._buildCornerWedgeMesh(name, sx, sy, sz);
            case 'ladder_vertical':
                // Лестница строится из stepCount ступенек — высота зависит от
                // количества ступенек, а не от sy.
                return this._buildLadderMesh(name, sx, sz, this._ladderStepCount || 8);
            default:
                return MeshBuilder.CreateBox(name,
                    { width: sx, height: sy, depth: sz }, this.scene);
@ -452,6 +476,43 @@ export class PrimitiveManager {
        return mesh;
    }
    /**
     * Вертикальная лестница: 2 боковые стойки + N перекладин (ступенек).
     * Полная высота = stepCount * LADDER_STEP_SPACING. При изменении stepCount
     * лестница ПЕРЕСТРАИВАЕТСЯ. Меш центрирован по (0,0,0) как CreateBox.
     * sx — ширина, sz — глубина стоек/перекладин.
     */
    _buildLadderMesh(name, sx, sz, stepCount) {
        const n = Math.max(2, Math.min(40, Math.round(stepCount || 8)));
        const SPACING = LADDER_STEP_SPACING;
        const height = n * SPACING;
        const railW = Math.min(0.12, sx * 0.12);
        const railD = Math.max(0.06, sz);
        const rungH = Math.min(0.1, SPACING * 0.3);
        const halfH = height / 2;
        const railX = sx / 2 - railW / 2;
        const parts = [];
        const railL = MeshBuilder.CreateBox(name + '_railL',
            { width: railW, height, depth: railD }, this.scene);
        railL.position.x = -railX;
        parts.push(railL);
        const railR = MeshBuilder.CreateBox(name + '_railR',
            { width: railW, height, depth: railD }, this.scene);
        railR.position.x = railX;
        parts.push(railR);
        const rungWidth = sx - railW;
        for (let i = 0; i < n; i++) {
            const y = -halfH + SPACING * (i + 0.5);
            const rung = MeshBuilder.CreateBox(name + '_rung' + i,
                { width: rungWidth, height: rungH, depth: railD }, this.scene);
            rung.position.y = y;
            parts.push(rung);
        }
        const merged = Mesh.MergeMeshes(parts, true, true, undefined, false, true);
        if (merged) { merged.name = name; return merged; }
        return MeshBuilder.CreateBox(name, { width: sx, height, depth: sz }, this.scene);
    }
    /** Применить цвет и материал. */
    _applyMaterial(mesh, typeDef, color, material, textureUrl) {
        const matName = `${mesh.name}_mat`;
@ -695,6 +756,14 @@ export class PrimitiveManager {
            data.studDensity = Number.isFinite(patch.studDensity) ? patch.studDensity : 1;
            scaleChanged = true;
        }
        // Лестница: смена числа ступенек → пересборка меша. Высота (sy)
        // деривируется из stepCount, поэтому AABB касания остаётся корректным.
        if (patch.stepCount !== undefined && data.type === 'ladder_vertical') {
            const sc = Math.max(2, Math.min(40, Math.round(patch.stepCount)));
            data.stepCount = sc;
            data.sy = sc * LADDER_STEP_SPACING;
            scaleChanged = true;
        }
        if (scaleChanged) {
            // Поскольку MeshBuilder уже создал mesh с базовыми размерами,
            // изменения через scaling кажутся правильными. Простой способ —
@ -828,7 +897,10 @@ export class PrimitiveManager {
        const oldMat = oldMesh.material;
        const typeDef = getPrimitiveType(data.type);
        // Лестница: передаём актуальный stepCount в builder.
        this._ladderStepCount = data.stepCount;
        const newMesh = this._createMeshForType(typeDef, data.id, data.sx, data.sy, data.sz, data.material, data.studDensity);
        this._ladderStepCount = undefined;
        newMesh.position = oldPos;
        if (oldRot) newMesh.rotation = oldRot;
        // studs — материал пересоздаём заново (свежий faceUV/тайлинг). Иначе перенос.
@ -904,6 +976,8 @@ export class PrimitiveManager {
            ...(d.light ? { brightness: d.brightness, range: d.range } : {}),
            // Параметр эмиттера (только для type='emitter')
            ...(d.effect !== undefined ? { effect: d.effect } : {}),
            // Число ступенек лестницы (только для type='ladder_vertical')
            ...(d.type === 'ladder_vertical' ? { stepCount: d.stepCount } : {}),
            // Параметры билборда (только для type='billboard')
            ...(d.billboard ? {
                template: d.billboard.template,
--- a/src/engine/PrimitiveTypes.js
+++ b/src/engine/PrimitiveTypes.js
@ -66,6 +66,13 @@ export const PRIMITIVE_TYPES = [
    { id: 'billboard', name: '3D-табличка', icon: 'prim-billboard', kind: 'billboard',
      defaultScale: { x: 2, y: 1.2, z: 0.05 }, defaultColor: '#1a1a2e' },
    // === Вертикальная лестница — по ней можно лазить вверх/вниз ===
    // Высота настраивается параметром stepCount (количество ступенек).
    // При изменении stepCount лестница перестраивается (НЕ растягивается модель,
    // а добавляются/убираются ступеньки). Касание → ladder-mode в PlayerController.
    { id: 'ladder_vertical', name: 'Лестница (вертикальная)', icon: 'prim-ladder', kind: 'ladder',
      defaultScale: { x: 1, y: 4, z: 0.12 }, defaultColor: '#a8743a' },
    // === GD-порталы (Geometry Dash 2.0) — переключают гейммод игрока ===
    // Все цилиндры-«столбы» с neon-материалом. Цвета и gdMode задают режим.
    { id: 'gd_cube',  name: 'Портал: Куб',    icon: 'prim-portal', kind: 'gd_portal', gdMode: 'cube',
@ -96,7 +103,7 @@ export const PRIMITIVE_TYPES = [
 /** Категории для группировки в палитре. */
 export const PRIMITIVE_CATEGORIES = [
    { id: 'geometry',   name: 'Фигуры',     ids: ['cube','sphere','cylinder','cone','plane','torus','wedge','cornerwedge'] },
-    { id: 'gameplay',   name: 'Геймплей',   ids: ['trigger', 'checkpoint', 'light', 'emitter', 'billboard'] },
+    { id: 'gameplay',   name: 'Геймплей',   ids: ['trigger', 'checkpoint', 'light', 'emitter', 'billboard', 'ladder_vertical'] },
    { id: 'gd-portals', name: 'GD-порталы', ids: ['gd_cube','gd_ship','gd_ball','gd_ufo','gd_wave','gd_robot'] },
    { id: 'gd-objects', name: 'GD-объекты', ids: ['gd_spike','gd_finish','gd_coin'] },
 ];
Author	SHA1	Message	Date
min	4fe86ee723	Merge pull request 'feat(player): �� fullscreen-�� (APK/desktop)' (#34 ) from feat/player-native-app-no-fs-prompt-2026-06-15 into main All checks were successful CI / Lint (push) Successful in 58s Details CI / Build (push) Successful in 1m32s Details CI / Secret scan (push) Successful in 21s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 3m1s Details	2026-06-15 19:25:05 +00:00
min	86620eee1c	feat(player): не показывать fullscreen-оверлей в нативном приложении All checks were successful CI / Lint (pull_request) Successful in 56s Details CI / Build (pull_request) Successful in 1m36s Details CI / Secret scan (pull_request) Successful in 24s Details CI / PR size check (pull_request) Successful in 7s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details В Android-приложении (Capacitor) и десктопе (Electron) WebView/окно уже на весь экран — стартовый оверлей «Нажми чтобы играть» избыточен (в браузере он нужен для user-gesture перед fullscreen, в нативе барьера нет). Теперь в нативном приложении игра запускается сразу: - IS_ANDROID_APP: детект по window.Capacitor + метке RubloxAndroid в UA; - IS_NATIVE_APP = desktop \|\| android; - gameStarted инициализируется true в нативе → оверлей пропускается; - handleGameStart/handleMobileStart не дёргают requestFullscreen в нативе. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-15 22:14:26 +03:00
min	e0f5ac9a29	Merge pull request 'feat(player): �� fullscreen � ��-��' (#33 ) from feat/player-desktop-no-fullscreen-2026-06-15 into main All checks were successful CI / Lint (push) Successful in 1m2s Details CI / Build (push) Successful in 1m34s Details CI / Secret scan (push) Successful in 21s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 3m0s Details	2026-06-15 17:27:43 +00:00
min	f77a741428	feat(player): не включать fullscreen в десктоп-приложении All checks were successful CI / Lint (pull_request) Successful in 57s Details CI / Build (pull_request) Successful in 1m31s Details CI / Secret scan (pull_request) Successful in 20s Details CI / PR size check (pull_request) Successful in 6s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details В Electron-обёртке (rublox-desktop) окно уже на весь экран без браузерной панели и вкладок — fullscreen не нужен (раньше защищал от Ctrl+W/Ctrl+T, в десктопе этого риска нет). По флагу window.__RUBLOX_DESKTOP__ (его ставит preload Electron): - handleGameStart/handleMobileStart не вызывают requestFullscreen; - стартовый текст «Нажми чтобы играть» без упоминания FS (показывает управление WASD); - пункт «Полноэкранный режим» в меню игры скрыт. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-15 20:17:27 +03:00
min	f2b74a2597	fix(skin): �� (#32 ) All checks were successful CI / Lint (push) Successful in 52s Details CI / Build (push) Successful in 1m28s Details CI / Secret scan (push) Successful in 20s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 2m59s Details	2026-06-15 05:21:27 +00:00
min	3754ecf4a1	fix(skin): валидация скина в карточках игроков (legacy bacon → y-bot) All checks were successful CI / Lint (pull_request) Successful in 52s Details CI / Build (pull_request) Successful in 1m28s Details CI / Secret scan (pull_request) Successful in 20s Details CI / PR size check (pull_request) Successful in 7s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details В меню «На сервере» аватарка бралась по player.skin. Если в БД legacy skin_bacon-hair (которого нет) — показывался бекон. Теперь невалидный скин (не в MIXAMO_SKINS) → аватар skin_y-bot, как и 3D-модель в игре. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-15 06:46:58 +03:00
min	b2b0eab546	feat(anim): 3-�� + �� (#31 ) All checks were successful CI / Lint (push) Successful in 54s Details CI / Build (push) Successful in 1m30s Details CI / Secret scan (push) Successful in 27s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 2m58s Details	2026-06-14 21:31:32 +00:00
min	71139def77	fix(skin): валидация скина из БД — fallback на y-bot для legacy All checks were successful CI / Lint (pull_request) Successful in 57s Details CI / Build (pull_request) Successful in 1m28s Details CI / Secret scan (pull_request) Successful in 19s Details CI / PR size check (pull_request) Successful in 5s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details Бэкенд отдаёт skin_bacon-hair как дефолт (22+ юзеров в БД с legacy R15), которого больше нет. Теперь если скин не в MIXAMO_SKINS (80 валидных) и не customskin: → fallback на skin_y-bot. Персонаж всегда загружается. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-15 00:19:36 +03:00
min	2294981597	feat(player): вертикальная лестница ladder_vertical + лазание - перенос из студии: ladder-mode, climb_up/climb_down, climb_to_top - предзагрузка climb-анимаций (нет дёрга 180° при входе) - заморозка позы на месте без исчезания скина - гистерезис выхода, толщина лестницы 0.12 - climb_to_top вылезание на площадку 4с с заморозкой физики Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 23:57:19 +03:00
min	42b3c26382	feat(anim): падение с края (fall_off) + coyote-фильтр спуска по лестнице - fall_off_air/fall_off_land при сходе с возвышенности без Space - coyote-фильтр по высоте падения (<1.3 блока → walk, не jump_air) убирает мигание анимаций при спуске по лестнице из блоков - jump_fwd_land / jump_run_land speedRatio 0.5 (присед виден) - land короче при движении (без скольжения), полный при остановке - компенсация Hips drop в land-фазах (ступни не уходят под пол) Все типы прыжка работают: in_place / forward / run / fall_off Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 21:49:37 +03:00
min	6782a42ba3	feat(anim): прыжок в беге (jump_run 3 фазы, Shift+движение) - jump_run_anticipate/air/land из Mixamo Running Jump - _jumpKind=run когда Shift+WASD в момент Space - speedRatio=0.71 для jump_run_air (синхрон 0.73с) - три типа: in_place / forward (шаг) / run (бег) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 21:07:44 +03:00
min	4db93592d2	feat(anim): прыжок вперёд при движении (jump_fwd 3 фазы) - jump_fwd_anticipate/air/land из Mixamo Jump (прыжок с разбега) - _jumpKind=forward когда нажата WASD в момент Space - speedRatio=0.59 для jump_fwd_air (синхрон с физикой 0.73с, без велосипеда) - in_place вариант остаётся для прыжка на месте Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 20:34:56 +03:00
min	eef7008416	feat(anim): 3-фазная анимация прыжка на месте (anticipate + air + land) - jump_anticipate (0.375с): присед перед прыжком, физика заблокирована, Hips опускается визуально - jump_air (0.975с): полёт без Hips.Y подъёма (физика управляет _modelRoot) - jump_land (0.56с): амортизация при приземлении, Hips опускается относительно maxY (никогда не выше bind — иначе ноги повиснут в воздухе) - Mixamo Jumping разрезан на 3 GLB через scripts/split_clip.js - Blender pipeline для FBX→GLB через scripts/fbx2glb_blender.py + strip_anim_channels.js - GameLoadingScreen убран при старте плеера (по умолчанию игра открывается сразу) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 20:25:30 +03:00
min	308b183db1	fix(skin): cache-bust character-assets URLs (#30 ) All checks were successful CI / Lint (push) Successful in 54s Details CI / Build (push) Successful in 1m29s Details CI / Secret scan (push) Successful in 1m21s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 2m55s Details	2026-06-14 13:43:18 +00:00
min	fc45d819e0	fix(skin): cache-bust query ?v=20260614 for character-assets URLs All checks were successful CI / Lint (pull_request) Successful in 55s Details CI / Build (pull_request) Successful in 1m29s Details CI / Secret scan (pull_request) Successful in 1m36s Details CI / PR size check (pull_request) Successful in 10s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details After backend CORS rollout users had stale CORS-failure cached for Mixamo GLB. Adding a query suffix forces browsers to re-fetch the URL instead of replaying the cached failure. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-06-14 16:34:31 +03:00
min	6c07a9f679	Merge pull request 'feat(player): crouch animations + fullscreen + skin from DB' (#29 ) from feat/crouch-animations-fullscreen-2026-06-14 into main All checks were successful CI / Lint (push) Successful in 54s Details CI / Build (push) Successful in 1m35s Details CI / Secret scan (push) Successful in 20s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 3m0s Details	2026-06-14 12:40:42 +00:00
min	ca1ce23205	feat(player): crouch animation system + fullscreen + skin from DB All checks were successful CI / Lint (pull_request) Successful in 57s Details CI / Build (pull_request) Successful in 1m33s Details CI / Secret scan (pull_request) Successful in 44s Details CI / PR size check (pull_request) Successful in 6s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details Этап 1 плана анимаций (ANIMATIONS_PLAN.md): CROUCH (Ctrl): - При зажатии Ctrl персонаж приседает, AABB → 0.45 - Скорость в crouch = 0.45×walk, crouch имеет приоритет над sprint - Анимации: crouch_enter (one-shot) → crouch_idle / crouch_walk - При вставании: crouch_to_stand (one-shot, если не движется) - Y-drop для разных Mixamo-клипов (crouch_idle: -0.45, walk: -0.25) - Anti-flicker debounce 120ms в MixamoAnimator FULLSCREEN + СТАРТ-ЭКРАН: - При запуске игры показывается оверлей "Нажми чтобы играть" - Клик → requestFullscreen() → Chrome блокирует Ctrl+W/D/T/R/S и др. - В fullscreen Esc отдаётся браузеру (выход), меню открывается на Tab - Без fullscreen — Esc открывает меню как обычно - BottomBar динамически показывает Esc/Tab в зависимости от режима СКИН ЮЗЕРА: - Приоритет: URL #skin=<id> → БД (rublox_equipped_skin) → localStorage → skin_y-bot - В Esc-меню "Участники" Mixamo-скины грузят PNG с /character-assets/skins/ MIXAMO ANIMATOR: - Полный класс с lazy-loading 35 состояний - AnimationGroup loop=true через onAnimationGroupEnd safety-net - crossFadeFrom для плавных переходов - Жёсткий stop всех не-current групп → нет фантомных анимаций	2026-06-14 15:29:13 +03:00
min	831b525cfc	Merge pull request 'restore: Mixamo + dev-skin через URL #skin=' (#28 ) from restore/mixamo-skin-2026-06-14 into main All checks were successful CI / Lint (push) Successful in 54s Details CI / Build (push) Successful in 1m31s Details CI / Secret scan (push) Successful in 19s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 3m3s Details	2026-06-14 08:11:26 +00:00
min	dbdd61b4d6	feat(player): dev-skin через URL #skin= + убран beforeunload All checks were successful CI / Lint (pull_request) Successful in 55s Details CI / Build (pull_request) Successful in 1m34s Details CI / Secret scan (pull_request) Successful in 27s Details CI / PR size check (pull_request) Successful in 10s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details LOCAL DEV: при запуске на localhost плеер берёт скин из: 1) hash-параметра #skin=<id> (сайт 3000 передаёт его при play-ticket через buildPlayerUrl(gameId, ticket, selectedSkin)) 2) localStorage самого плеера (rublox_selected_skin) 3) дефолт skin_y-bot Это нужно потому что: - localStorage на :5173 (плеер) и :3000 (сайт) — РАЗНЫЕ хранилища - В прод-БД пока legacy-скины (skin_sigma-labubu и др.), пока feature-flag RUBLOX_NEW_SKINS_AVAILABLE=false плеер не должен в неё лезть локально PROD: только БД (rublox_equipped_skin) — поведение не меняется. Также убран beforeunload-prompt: системное окно браузера невозможно стилизовать (Chrome игнорирует кастомный текст с 2017), а уродливое окно мешало. Случайное закрытие вкладки теперь без подтверждения.	2026-06-14 11:02:47 +03:00
min	8047cd366c	Revert "Merge pull request 'revert: �� Mixamo skin support' (#27 ) from revert/mixamo-skin-2026-06-13 into main" This reverts commit 62ff0b01007684ed9ffdf6e550f7d257f58c3f9e, reversing changes made to 830f4b8f4a2055e5e596a95b3268e30619c34724.	2026-06-14 11:02:25 +03:00
min	62ff0b0100	Merge pull request 'revert: �� Mixamo skin support' (#27 ) from revert/mixamo-skin-2026-06-13 into main All checks were successful CI / Lint (push) Successful in 56s Details CI / Build (push) Successful in 1m32s Details CI / Secret scan (push) Successful in 20s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 2m57s Details	2026-06-13 09:56:56 +00:00
min	91870d7a09	Revert "feat(skin): Mixamo 80 + fallback �� legacy R15 (#26 )" All checks were successful CI / Lint (pull_request) Successful in 55s Details CI / Build (pull_request) Successful in 1m41s Details CI / Secret scan (pull_request) Successful in 21s Details CI / PR size check (pull_request) Successful in 6s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details This reverts commit 830f4b8f4a2055e5e596a95b3268e30619c34724, reversing changes made to 7d6e14a08fe2fcf0709a846f9a5efba536dd7184.	2026-06-13 12:50:26 +03:00
min	830f4b8f4a	feat(skin): Mixamo 80 + fallback �� legacy R15 (#26 ) All checks were successful CI / Lint (push) Successful in 57s Details CI / Build (push) Successful in 1m31s Details CI / Secret scan (push) Successful in 20s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 3m3s Details	2026-06-13 07:38:22 +00:00
min	94da0e1409	feat(skin): Mixamo-палитра 80 скинов + fallback на legacy R15 All checks were successful CI / Lint (pull_request) Successful in 56s Details CI / Build (pull_request) Successful in 1m38s Details CI / Secret scan (pull_request) Successful in 25s Details CI / PR size check (pull_request) Successful in 8s Details CI / Deploy to S1 + S2 (pull_request) Has been skipped Details Что: - _resolveModelSource: * Mixamo (skin_y-bot/x-bot/eve/...) → /character-assets/skins/<id>.glb (с rublox-site, non-humanoid-rigged kind) * Legacy R15 (skin_bacon-hair, skin_sigma-labubu и др.) — сохранена старая ветка через manifest + /kubikon-assets/. Это нужно пока бэк storys работает в legacy-режиме (RUBLOX_NEW_SKINS_AVAILABLE != true). - skinFolderRef.current default: skin_bacon-hair → skin_y-bot - BabylonScene._playerModelType default + миграция character-* → skin_y-bot - PlayerController._modelTypeId default → skin_y-bot - MultiplayerSync: все дефолты → skin_y-bot LOCAL DEV: - На localhost плеер сначала пробует localStorage('rublox_selected_skin') (тот же ключ что в rublox-site), потом БД. Это позволяет тестить выбор скина в сайте без записи в прод-БД. Зависит от: - PR storys (новый бэк-резолв + feature-flag) - PR user (endpoint /<id>/gender) - Заливки 80 GLB на rublox.pro/character-assets/skins/ (отдельная инфра-задача)	2026-06-13 10:24:37 +03:00
min	7d6e14a08f	Merge pull request '��: �� let _lsMirror � worker �� ' (#25 ) from fix/env-production-ci into main All checks were successful CI / Lint (push) Successful in 54s Details CI / Build (push) Successful in 1m29s Details CI / Secret scan (push) Successful in 26s Details CI / PR size check (push) Has been skipped Details CI / Deploy to S1 + S2 (push) Successful in 2m58s Details	2026-06-11 19:05:38 +00:00