Merge pull request '�������/������� (������� �� �������) + realtime �� game.rublox.pro' (#24) from fix/env-production-ci into main

GraphicsManager (постобработка/материалы/API game.graphics) — паритет со студией,
применяется при загрузке игры если автор настроил. Новые материалы chrome/water/
iridescent. Realtime-эндпоинт переведён на game.rublox.pro (S1 NPM прямо, без
hop через S2 — чинит разрывы WebSocket). MultiplayerSync улучшен.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.WORKTREE_NOTICE.md

@@ -0,0 +1,11 @@
+# Активная сессия: импорт Roblox .rbxl
+
+Это **отдельный worktree** для разработки `feat/rbxl-import` — импорта Roblox-карт в Rublox.
+
+**Не работайте здесь параллельно из других сессий!**
+
+Ветка: `feat/rbxl-import`
+Сервис на сервере: VM 130 на S1
+Сопутствующий worktree: `Desktop/studio-rbxl-import`
+
+Started: 2026-06-07

package-lock.json

@@ -18,7 +18,8 @@
         "react": "18.3.1",
         "react-dom": "18.3.1",
         "react-router-dom": "7.4.0",
-        "socket.io-client": "^4.8.3"
+        "socket.io-client": "^4.8.3",
+        "wasmoon": "^1.16.0"
       },
       "devDependencies": {
         "@types/react": "18.3.12",
@@ -1427,6 +1428,12 @@
       "integrity": "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==",
       "license": "MIT"
     },
+    "node_modules/@types/emscripten": {
+      "version": "1.39.10",
+      "resolved": "https://registry.npmjs.org/@types/emscripten/-/emscripten-1.39.10.tgz",
+      "integrity": "sha512-TB/6hBkYQJxsZHSqyeuO1Jt0AB/bW6G7rHt9g7lML7SOF6lbgcHvw/Lr+69iqN0qxgXLhWKScAon73JNnptuDw==",
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -5206,6 +5213,18 @@
         }
       }
     },
+    "node_modules/wasmoon": {
+      "version": "1.16.0",
+      "resolved": "https://registry.npmjs.org/wasmoon/-/wasmoon-1.16.0.tgz",
+      "integrity": "sha512-FlRLb15WwAOz1A9OQDbf6oOKKSiefi5VK0ZRF2wgH9xk3o5SnU11tNPaOnQuAh1Ucr66cwwvVXaeVRaFdRBt5g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/emscripten": "1.39.10"
+      },
+      "bin": {
+        "wasmoon": "bin/wasmoon"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",

package.json

@@ -49,7 +49,8 @@
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-router-dom": "7.4.0",
-    "socket.io-client": "^4.8.3"
+    "socket.io-client": "^4.8.3",
+    "wasmoon": "^1.16.0"
   },
   "devDependencies": {
     "@types/react": "18.3.12",

src/KubikonPlayer/GameLoadingScreen.jsx

@@ -0,0 +1,198 @@
+/**
+ * GameLoadingScreen — красивый экран загрузки игры в плеере (задача 05).
+ *
+ * Показывается пока грузится игра (после клика «Играть» на странице игры →
+ * открытие плеера). Композиция как в Roblox:
+ *   - размытый фон-обложка игры с медленным Ken Burns (pan + zoom);
+ *   - карточка-витрина по центру (обложка игры);
+ *   - крупное название места;
+ *   - автор + verified-галочка;
+ *   - прогресс-бар + спиннер «ЗАГРУЗКА».
+ *
+ * Данные берёт из меты игры (title/thumbnail/автор) и, если автор настроил в
+ * студии вкладку «Стартовый экран» — из project_data.scene.loadingScreen
+ * (placeName / studioName / style / verified / background / cover).
+ */
+import React, { useEffect, useRef, useState } from 'react';
+
+// Один раз вставляем CSS-keyframes (нельзя инлайнить в style).
+let _cssInjected = false;
+function injectCss() {
+    if (_cssInjected || typeof document === 'undefined') return;
+    _cssInjected = true;
+    const s = document.createElement('style');
+    s.id = 'kbn-game-loading-css';
+    s.textContent =
+        '@keyframes kbnGlsKen{0%{transform:scale(1.05) translate3d(0,0,0)}50%{transform:scale(1.15) translate3d(-3%,-2%,0)}100%{transform:scale(1.05) translate3d(-6%,0,0)}}' +
+        '.kbnGlsKen{animation:kbnGlsKen 22s ease-in-out infinite}' +
+        '@keyframes kbnGlsSpin{to{transform:rotate(360deg)}}' +
+        '.kbnGlsSpin{animation:kbnGlsSpin 0.85s linear infinite}' +
+        '@keyframes kbnGlsRise{0%{transform:translateY(0) scale(1);opacity:0}12%{opacity:.9}88%{opacity:.6}100%{transform:translateY(-110vh) scale(1.4);opacity:0}}' +
+        '.kbnGlsP{animation:kbnGlsRise linear infinite}' +
+        '@keyframes kbnGlsGlow{0%,100%{box-shadow:0 18px 60px rgba(0,0,0,.6),0 0 0 rgba(120,160,255,0)}50%{box-shadow:0 18px 60px rgba(0,0,0,.6),0 0 44px rgba(120,160,255,.4)}}' +
+        '.kbnGlsCard{animation:kbnGlsGlow 4s ease-in-out infinite}' +
+        '@keyframes kbnGlsBar{0%{transform:translateX(-100%)}100%{transform:translateX(250%)}}' +
+        '.kbnGlsBarRun{animation:kbnGlsBar 1.2s ease-in-out infinite}' +
+        '@media (prefers-reduced-motion:reduce){.kbnGlsKen,.kbnGlsP,.kbnGlsCard,.kbnGlsBarRun{animation:none}}';
+    document.head.appendChild(s);
+}
+
+function VerifiedBadge() {
+    return (
+        <svg width="18" height="18" viewBox="0 0 24 24" style={{ flex: '0 0 auto' }} aria-label="verified">
+            <circle cx="12" cy="12" r="11" fill="#3897f0" />
+            <path d="M7 12.5l3 3 7-7" fill="none" stroke="#fff" strokeWidth="2.4"
+                strokeLinecap="round" strokeLinejoin="round" />
+        </svg>
+    );
+}
+
+/**
+ * props:
+ *   meta          — ответ getProjectForPlay (title, thumbnail, author_username/username, ...)
+ *   loadingScreen — project_data.scene.loadingScreen (опц., настройки автора)
+ *   progress      — 0..1 (если null — «бегущая» полоса без процента)
+ */
+export default function GameLoadingScreen({ meta, loadingScreen, progress }) {
+    injectCss();
+    const ls = loadingScreen || {};
+    const [fade, setFade] = useState(0);
+    const rootRef = useRef(null);
+
+    useEffect(() => { const t = setTimeout(() => setFade(1), 20); return () => clearTimeout(t); }, []);
+
+    // Источники данных: настройки автора → мета игры → дефолт.
+    const bg = ls.background || meta?.thumbnail || null;
+    const cover = ls.cover || meta?.thumbnail || null;
+    const placeName = ls.placeName || meta?.title || 'Загрузка игры';
+    const studioName = ls.studioName
+        || meta?.author_username || meta?.username || meta?.author || '';
+    const verified = ls.verified != null ? !!ls.verified
+        : !!(meta?.author_verified || meta?.is_verified);
+    const style = ls.style || 'ken-burns';
+    const accent = ls.accentColor || '#5fd0ff';
+    const hasProgress = typeof progress === 'number' && progress >= 0;
+    const pct = hasProgress ? Math.round(Math.max(0, Math.min(1, progress)) * 100) : null;
+
+    // parallax по мыши
+    const bgRef = useRef(null);
+    useEffect(() => {
+        if (style !== 'parallax' || !bgRef.current) return;
+        const h = (e) => {
+            const cx = (e.clientX / window.innerWidth - 0.5) * 26;
+            const cy = (e.clientY / window.innerHeight - 0.5) * 16;
+            if (bgRef.current) bgRef.current.style.transform = `translate3d(${-cx}px,${-cy}px,0) scale(1.1)`;
+        };
+        window.addEventListener('mousemove', h);
+        return () => window.removeEventListener('mousemove', h);
+    }, [style]);
+
+    const particles = style === 'particles'
+        ? Array.from({ length: 24 }, (_, i) => {
+            const size = 2 + (i % 4);
+            const dur = 7 + (i % 7);
+            return (
+                <span key={i} className="kbnGlsP" style={{
+                    position: 'absolute', bottom: -10, left: `${(i * 37) % 100}%`,
+                    width: size, height: size, borderRadius: '50%',
+                    background: `rgba(${180 + (i * 7) % 70},${190 + (i * 5) % 60},255,0.85)`,
+                    boxShadow: `0 0 ${size * 2}px rgba(140,170,255,0.7)`,
+                    animationDuration: `${dur}s`, animationDelay: `${-(i % 7)}s`,
+                }} />
+            );
+        }) : null;
+
+    return (
+        <div ref={rootRef} style={{
+            position: 'absolute', inset: 0, zIndex: 60, overflow: 'hidden',
+            display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center',
+            background: 'radial-gradient(ellipse at center, #0e1430 0%, #070a14 70%)',
+            opacity: fade, transition: 'opacity 0.4s ease',
+            fontFamily: 'system-ui,"Segoe UI",sans-serif',
+        }}>
+            {/* Фоновый слой (Ken Burns / parallax / static) */}
+            {bg && (
+                <div ref={bgRef}
+                    className={style === 'ken-burns' ? 'kbnGlsKen' : undefined}
+                    style={{
+                        position: 'absolute', inset: '-8%', zIndex: 0,
+                        backgroundImage: `url("${bg}")`, backgroundSize: 'cover', backgroundPosition: 'center',
+                        filter: 'blur(9px) brightness(0.5)', willChange: 'transform',
+                        transition: style === 'parallax' ? 'transform 0.25s ease-out' : 'none',
+                    }} />
+            )}
+            {/* particles */}
+            {particles && <div style={{ position: 'absolute', inset: 0, zIndex: 1, pointerEvents: 'none' }}>{particles}</div>}
+
+            {/* Контент */}
+            <div style={{
+                position: 'relative', zIndex: 2, display: 'flex',
+                flexDirection: 'column', alignItems: 'center',
+            }}>
+                {/* Карточка-витрина */}
+                <div className="kbnGlsCard" style={{
+                    width: 'min(40vw,300px)', aspectRatio: '1/1', borderRadius: 18,
+                    backgroundImage: cover ? `url("${cover}")` : 'none',
+                    backgroundColor: '#1a1f2b', backgroundSize: 'cover', backgroundPosition: 'center',
+                    border: '2px solid rgba(255,255,255,0.14)',
+                    display: 'flex', alignItems: 'center', justifyContent: 'center',
+                }}>
+                    {!cover && (
+                        <span style={{ color: '#5a6178', fontSize: 14, fontWeight: 700 }}>РУБЛОКС • 3D</span>
+                    )}
+                </div>
+
+                {/* Название места */}
+                <div style={{
+                    marginTop: 22, color: '#fff', fontSize: 34, fontWeight: 800,
+                    letterSpacing: 0.4, textAlign: 'center', maxWidth: '80vw',
+                    textShadow: '0 3px 14px rgba(0,0,0,0.7)',
+                }}>{placeName}</div>
+
+                {/* Автор + verified */}
+                {studioName && (
+                    <div style={{
+                        marginTop: 8, display: 'flex', alignItems: 'center', gap: 7,
+                        color: '#cdd6e6', fontSize: 16, fontWeight: 600,
+                        textShadow: '0 1px 4px rgba(0,0,0,0.6)',
+                    }}>
+                        <span>{studioName}</span>
+                        {verified && <VerifiedBadge />}
+                    </div>
+                )}
+
+                {/* Прогресс-бар */}
+                <div style={{
+                    marginTop: 26, width: 'min(64vw,420px)', height: 10, borderRadius: 6,
+                    background: 'rgba(255,255,255,0.12)', overflow: 'hidden',
+                    boxShadow: 'inset 0 1px 3px rgba(0,0,0,0.5)', position: 'relative',
+                }}>
+                    {hasProgress ? (
+                        <div style={{
+                            height: '100%', width: `${pct}%`, borderRadius: 6,
+                            background: `linear-gradient(90deg, ${accent}, #ffffff)`,
+                            transition: 'width 0.2s linear', boxShadow: `0 0 10px ${accent}`,
+                        }} />
+                    ) : (
+                        <div className="kbnGlsBarRun" style={{
+                            height: '100%', width: '40%', borderRadius: 6,
+                            background: `linear-gradient(90deg, transparent, ${accent}, transparent)`,
+                        }} />
+                    )}
+                </div>
+
+                {/* Спиннер + статус */}
+                <div style={{
+                    marginTop: 16, display: 'flex', alignItems: 'center', gap: 12,
+                    color: '#fff', fontSize: 15, fontWeight: 700, letterSpacing: 0.5,
+                }}>
+                    <span className="kbnGlsSpin" style={{
+                        display: 'inline-block', width: 20, height: 20,
+                        border: '3px solid rgba(255,255,255,0.25)', borderTopColor: accent, borderRadius: '50%',
+                    }} />
+                    {pct != null ? `${pct}%` : 'ЗАГРУЗКА'}
+                </div>
+            </div>
+        </div>
+    );
+}

src/KubikonPlayer/KubikonPlayer.jsx

@@ -22,7 +22,8 @@ import { useAuth } from '../auth/PlayerAuth';
 import RublocsLogo from '../components/RublocsLogo/RublocsLogo';
 import useDeviceType from '../hooks/useDeviceType';
 import KubikonMobileControls from './KubikonMobileControls';
-// загрузка плейсов начинается на строке 1181
+import GameLoadingScreen from './GameLoadingScreen';
+
 // Плеер живёт на player.rublox.pro — он не знает SPA-роутов Майнкрафтии
 // (/kubikon, /login, /auth). Поэтому вместо navigate(...) делаем
 // явный window.location.assign на внешний домен.
@@ -38,12 +39,12 @@ function exitPlayer(gameId) {
     // (флаг читает onBeforeUnload listener ниже).
     try { window.__rubloxExplicitExit = true; } catch {}
     const env = (typeof import.meta !== 'undefined' && import.meta.env) || {};
-    const RUBLOX_HOME = env.VITE_RUBLOX_HOME || 'https://rublox.pro/app';
+    const RUBLOX_HOME = (env.VITE_RUBLOX_HOME || 'https://rublox.pro/app').replace(/\/+$/, '');
     if (gameId) {
-        // Передаём gameId через ?game=<id> — главный сайт прочитает и снова
+        // У страницы игры теперь свой URL: /app/game/<id> (им можно делиться).
-        // откроет карточку игры (юзер возвращается на ту же страницу).
+        // Возвращаемся прямо на него. base RUBLOX_HOME оканчивается на /app.
-        const sep = RUBLOX_HOME.includes('?') ? '&' : '?';
+        const base = RUBLOX_HOME.endsWith('/app') ? RUBLOX_HOME : `${RUBLOX_HOME}/app`;
-        window.location.assign(`${RUBLOX_HOME}${sep}game=${gameId}`);
+        window.location.assign(`${base}/game/${gameId}`);
     } else {
         window.location.assign(RUBLOX_HOME);
     }
@@ -216,6 +217,9 @@ const KubikonPlayer = () => {
     const [forbidden, setForbidden] = useState(false);
     const [error, setError] = useState(null);
     const [loading, setLoading] = useState(true);
+    // Задача 05: конфиг красивого экрана загрузки (из project_data.scene.loadingScreen).
+    const [loadingScreenCfg, setLoadingScreenCfg] = useState(null);
+    const [loadProgress, setLoadProgress] = useState(0);
     // Раньше была стартовая заглушка «тапни чтобы начать» — убрали по
     // фидбэку, она бесила. Теперь fullscreen опционально через кнопку
     // в углу. Этот state остался для совместимости с handleMobileStart.
@@ -252,9 +256,6 @@ const KubikonPlayer = () => {
     // Появляется после submitLeaderboard если бэк выдал rating_award текущему юзеру.
     // null | { place: 1|2|3, amount: number }
     const [ratingToast, setRatingToast] = useState(null);
-    const [placeName, setPlaceName] = useState('Загрузка игры…');
-    const [placeImage, setPlaceImage] = useState(null);
-    const [studioName, setStudioName] = useState(null);
     const timerRafRef = useRef(null);
     /** Кэш загруженного project_data для soft-restart игры. */
     const initialStateRef = useRef(null);
@@ -554,11 +555,18 @@ const KubikonPlayer = () => {
                 setMeta(data);
                 setLikesCount(data.likes_count || 0);
                 setDislikesCount(data.dislikes_count || 0);
+                setLoadProgress(0.3);
 
                 if (data.project_data) {
                     const parsed = JSON.parse(data.project_data);
                     initialStateRef.current = parsed;
+                    // Задача 05: красивый экран загрузки — конфиг автора (если задан в студии).
+                    try {
+                        const lsc = parsed?.scene?.loadingScreen;
+                        if (lsc && typeof lsc === 'object' && lsc.enabled !== false) setLoadingScreenCfg(lsc);
+                    } catch (e) { /* ignore */ }
                     await scene.loadFromState(parsed);
+                    setLoadProgress(0.7);
                 }
 
                 // Ждём пока Babylon реально загрузит и скомпилит все
@@ -595,6 +603,7 @@ const KubikonPlayer = () => {
                 skinFolderRef.current = mySkin;
                 try { scene.setPlayerModelType?.(mySkin); } catch (e) {}
 
+                setLoadProgress(1);
                 setLoading(false);
                 // Засчитываем плей. Передаём user_id (если залогинен) —
                 // это активирует self-cooldown (автор не накручивает себе)
@@ -689,47 +698,6 @@ const KubikonPlayer = () => {
         return () => { alive = false; clearInterval(t); };
     }, [projectId, userId, sessionId, loading]);
 
-    // Загрузка названия и картинки плейса с сервера
-    // Загрузка названия, картинки и автора плейса с сервера
-    // Загрузка названия, картинки и автора плейса
-    useEffect(() => {
-        if (!projectId) return;
-        if (!userId) {
-            console.log('[Loading] Ждём userId...');
-            return; // Ждём пока userId загрузится
-        }
-    
-        async function loadPlaceData() {
-            try {
-                // Пытаемся загрузить данные через API
-                const response = await Kubikon3DApi.getProjectForPlay(projectId, userId);
-                const title = response?.data?.title;
-                const thumbnail = response?.data?.thumbnail;
-                const author = response?.data?.author_username;
-            
-                if (title) {
-                    setPlaceName(title);
-                } else {
-                    setPlaceName(`Плейс ${projectId}`);
-                }
-            
-                if (thumbnail) {
-                    setPlaceImage(thumbnail);
-                }
-            
-                if (author) {
-                    setStudioName(author);
-                }
-            
-            } catch (error) {
-                console.warn('[KubikonPlayer] Не удалось загрузить данные плейса:', error);
-                setPlaceName(`Плейс ${projectId}`);
-            }
-        }
-    
-        loadPlaceData();
-    }, [projectId, userId]); // Убрал meta из зависимостей!
-
     // Хоткеи 1-5 для слотов инвентаря.
     // Babylon ловит ввод на canvas — слушаем в capture-phase на window
     // и не привязываемся к isPlaying (state-флаг может быть ещё false на старте).
@@ -1014,6 +982,11 @@ const KubikonPlayer = () => {
                 // Очищаем ref'ы — иначе следующий connectMultiplayer выйдет
                 // на if (mpSyncRef.current || roomRef.current) return.
                 try { sync.stop?.(); } catch (e) {}
+                // ВАЖНО: dispose() сносит ВСЕ старые меши remote-игроков со
+                // сцены. Без этого при auto-reconnect (Colyseus rejoin) новый
+                // MultiplayerSync видит пустую Map и при +remote создаёт
+                // дубль-меш на каждый кадр (см. фикс 2026-06-05).
+                try { sync.dispose?.(); } catch (e) {}
                 mpSyncRef.current = null;
                 roomRef.current = null;
                 // Code 1000 / 1001 — нормальное закрытие. Code >= 4000 — наш
@@ -1177,73 +1150,14 @@ const KubikonPlayer = () => {
                         outline: 'none',
                     }}
                 />
-                {/* Loading-оверлей */}
+                {/* Задача 05: красивый экран загрузки игры (Ken Burns + название места + автор). */}
-                {/*не меняйте пожалуйста загрузку, работаю над ней*/}
                 {loading && (
-                    <div style={{
+                    <GameLoadingScreen
-                        position: 'absolute', inset: 0,
+                        meta={meta}
-                        display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center',
+                        loadingScreen={loadingScreenCfg}
-                        background: 'radial-gradient(ellipse at center, rgba(51,87,255,0.22) 0%, rgba(7,10,20,0.96) 60%)',
+                        progress={loadProgress}
-                        gap: 18, color: HUD.text,
+                    />
-                        zIndex: 50,
-                    }}>
-                        <div style={{
-                            position: 'relative',
-                            animation: 'hudFloat 3s ease-in-out infinite',
-                        }}>
-                            <div style={{
-                                position: 'absolute', inset: -10,
-                                borderRadius: 20,
-                                animation: 'hudPulseRing 1.6s ease-out infinite',
-                            }} />
-                            {placeImage ? (
-                                <img 
-                                    src={placeImage} 
-                                    alt={placeName}
-                                    style={{
-                                        width: 90, height: 90,
-                                        borderRadius: 16,
-                                        objectFit: 'cover',
-                                        boxShadow: '0 6px 20px rgba(0,0,0,0.4)',
-                                    }}
-                                />
-                            ) : (
-                                <RublocsLogo size={90} />
-                            )}
-                        </div>
-                        {/* Полупрозрачный тёмно-серый пузырь для текста */}
-                        <div style={{
-                            background: 'rgba(30, 35, 55, 0.6)',
-                            borderRadius: 60,
-                            padding: '10px 24px',
-                            marginTop: 8,
-                        }}>
-                            <div style={{
-                                display: 'flex', alignItems: 'center', gap: 10,
-                                fontSize: 15, fontWeight: 700, letterSpacing: 0.3,
-                            }}>
-                                <div style={{
-                                    width: 14, height: 14,
-                                    border: `2.5px solid ${HUD.accentBg}`,
-                                    borderTopColor: "#ffffff",
-                                    borderRadius: '50%',
-                                    animation: 'hudSpin 0.8s linear infinite',
-                                }} />
-                                {placeName || 'Загрузка игры…'}
-                            </div>
-    
-                            <div style={{
-                                fontSize: 13, color: HUD.textDim,
-                                textTransform: 'uppercase', letterSpacing: 1.4, fontWeight: 700,
-                                textAlign: 'center',
-                                marginTop: 6,
-                            }}>
-                                {studioName || 'Имя автора'}
-                            </div>
-                         </div>
-                    </div>
                 )}
-                {/* Игровой UI (HUD, GUI, hotbar, прицел в первом лице) */}
 
                 {/* Игровой UI (HUD, GUI, hotbar, прицел в первом лице) */}
                 {!loading && (

src/api/API.js

@@ -30,10 +30,13 @@ export const STORYS_addres = BASE + '/api-storys';
 // env-настроенные прямые URL.
 const IS_HTTPS = typeof window !== 'undefined' && window.location.protocol === 'https:';
 
+// 2026-06-05: realtime теперь прямо на game.rublox.pro (S1 NPM → S1 VM 110),
+// не через minecraftia-school.ru/api-game (лишний hop S2 NPM → S1 NAT
+// давал разрывы WebSocket каждую секунду).
 export const REALTIME_HTTP = ENV.VITE_REALTIME_HTTP
-    ?? (IS_HTTPS ? `${window.location.origin}/api-game` : 'http://localhost:8685');
+    ?? (IS_HTTPS ? 'https://game.rublox.pro' : 'http://localhost:8685');
 export const REALTIME_WS = ENV.VITE_REALTIME_WS
-    ?? (IS_HTTPS ? `wss://${window.location.host}/api-game` : 'ws://localhost:8685');
+    ?? (IS_HTTPS ? 'wss://game.rublox.pro' : 'ws://localhost:8685');
 
 // Главный сайт Рублокса — куда редиректить юзеров без ticket/JWT.
 export const RUBLOX_HOME = ENV.VITE_RUBLOX_HOME ?? 'https://rublox.pro/app';

src/engine/BabylonScene.js

@@ -96,6 +96,7 @@ import { GdForest } from './GdForest';
 import { GdPlayerCube } from './GdPlayerCube';
 import { GdPlayerTrail } from './GdPlayerTrail';
 import { GdPostFx } from './GdPostFx';
+import { GraphicsManager } from './GraphicsManager';
 import { PhysicsAABB } from './PhysicsAABB';
 import { PlayerController } from './PlayerController';
 import { SelectionManager } from './SelectionManager';
@@ -1649,6 +1650,42 @@ export class BabylonScene {
         this._ssaoEnabled = false;
     }
 
+    /**
+     * Система графики/эффектов («шейдеры»). Лениво создаём GraphicsManager.
+     * Идентична студийной (фича-парность). Применяется при загрузке игры,
+     * если автор настроил graphics в проекте (и не 'off').
+     */
+    _ensureGraphics() {
+        if (this._graphics) {
+            const cam = this.scene?.activeCamera || this.camera;
+            if (cam) this._graphics.setCamera(cam);
+            return this._graphics;
+        }
+        const cam = this.scene?.activeCamera || this.camera;
+        if (!this.scene || !cam) return null;
+        this._graphics = new GraphicsManager(this.scene, cam, this, {
+            mobile: !!this._isMobileMode,
+        });
+        return this._graphics;
+    }
+
+    setGraphics(settings) {
+        const g = this._ensureGraphics();
+        if (!g) return null;
+        const cfg = g.apply(settings || {});
+        this._graphicsConfig = cfg;
+        return cfg;
+    }
+
+    getGraphicsState() {
+        return this._graphics ? this._graphics.serialize() : (this._graphicsConfig || null);
+    }
+
+    disableGraphics() {
+        if (this._graphics) this._graphics.disableAll();
+        this._graphicsConfig = null;
+    }
+
     /**
      * Включить/выключить SSAO пост-эффект (контактные тени).
      * Используем SSAORenderingPipeline v1 — v2 ломал thin-instance рендер
@@ -2863,6 +2900,7 @@ export class BabylonScene {
         if (md.isBlock) {
             return { kind: 'block', ref: { x: md.gridX, y: md.gridY, z: md.gridZ } };
         }
+        if (md.npcId != null) return { kind: 'npc', id: md.npcId };
         if (md.isModel) return { kind: 'model', id: md.instanceId };
         if (md.isPrimitive) return { kind: 'primitive', id: md.primitiveId };
         return null;
@@ -3104,7 +3142,29 @@ export class BabylonScene {
             }
         }
 
-        const pick = this._pickFromCenter();
+        // В pointer-lock (1-е лицо) курсор скрыт в центре — пикаем центром.
+        // В 3-м лице (свободный курсор) — пикаем по реальным координатам клика.
+        const locked = (document.pointerLockElement === this.canvas);
+        let pick;
+        if (!locked && Number.isFinite(clickX) && Number.isFinite(clickY)) {
+            const pi = this.scene.pick(clickX, clickY, (mesh) => {
+                if (!mesh.isPickable) return false;
+                if (mesh.name && mesh.name.startsWith('gridLine')) return false;
+                return true;
+            });
+            if (pi?.hit) {
+                let m = pi.pickedMesh;
+                if (m?.metadata?._isBlockProto && this.blockManager) {
+                    const proxy = this.blockManager.findProxyByPickInfo?.(pi);
+                    if (proxy) m = proxy;
+                }
+                pick = { mesh: m, point: pi.pickedPoint, pickInfo: pi };
+            } else {
+                pick = null;
+            }
+        } else {
+            pick = this._pickFromCenter();
+        }
         const target = pick?.mesh ? this._meshToTarget(pick.mesh) : null;
         const point = pick?.point ? { x: pick.point.x, y: pick.point.y, z: pick.point.z } : null;
         // 1) Self-onClick — только если target есть
@@ -5413,6 +5473,56 @@ export class BabylonScene {
         return this._isPlaying;
     }
 
+    /** Задача 12+05: конфиг экрана загрузки из настроек проекта. */
+    setLoadingConfig(cfg, thumbnail) {
+        if (cfg && typeof cfg === 'object') {
+            this._loadingConfig = {
+                logo: cfg.logo || null,
+                accentColor: cfg.accentColor || '#ffc020',
+                defaultSpinner: cfg.defaultSpinner !== false,
+                defaultSkipButton: !!cfg.defaultSkipButton,
+                // Задача 05:
+                enabled: cfg.enabled !== false,
+                background: cfg.background || cfg.backgroundUrl || null,
+                cover: cfg.cover || cfg.coverUrl || null,
+                style: cfg.style || 'ken-burns',
+                placeName: cfg.placeName || '',
+                studioName: cfg.studioName || '',
+                verified: !!cfg.verified,
+                duration: Number.isFinite(cfg.duration) && cfg.duration > 0 ? Number(cfg.duration) : 2.5,
+                progressBar: cfg.progressBar !== false,
+            };
+        } else {
+            this._loadingConfig = null;
+        }
+        if (thumbnail !== undefined) this._projectThumbnail = thumbnail || null;
+    }
+
+    /** Задача 05: стартовый экран загрузки при входе в Play (Ken-Burns + название места). */
+    showStartupLoadingScreen() {
+        const cfg = this._loadingConfig;
+        if (!cfg || cfg.enabled === false) return;
+        if (!this.gameRuntime) return;
+        try {
+            const ls = this.gameRuntime._ensureLoadingScreen?.();
+            if (!ls) return;
+            ls.show({
+                style: cfg.style,
+                background: cfg.background || cfg.cover || this._projectThumbnail,
+                cover: cfg.cover || this._projectThumbnail,
+                placeName: cfg.placeName || this._projectName || '',
+                studioName: cfg.studioName || '',
+                verified: cfg.verified,
+                duration: cfg.duration,
+                progressBar: cfg.progressBar,
+                spinner: true,
+                bgColor: '#070a14',
+                pauseSimulation: false,
+                blockInput: true,
+            });
+        } catch (e) { /* ignore */ }
+    }
+
     /**
      * Переключить в режим игры. Создаём PlayerController, прячем ghost-блок,
      * запоминаем позицию редактор-камеры чтобы вернуть при exit.
@@ -5526,6 +5636,8 @@ export class BabylonScene {
         // поэтому скрипты стартуем в следующем кадре.
         this.gameRuntime = new GameRuntime(this);
         try { this.modalManager?.attachRuntime?.(this.gameRuntime); } catch (e) {}
+        // Задача 05: стартовый экран загрузки (Ken-Burns + название места).
+        try { this.showStartupLoadingScreen(); } catch (e) {}
         // Аудио-менеджер (GD-музыка/SFX) — создаётся вместе с runtime.
         // ВАЖНО: поле называется gameAudioManager чтобы не путать со штатным
         // this.audioManager (AudioManager — ambient/music для всех проектов).
@@ -7431,15 +7543,9 @@ export class BabylonScene {
         } else {
             this._skinsConfig = null;
         }
-        // Задача 12: конфиг экрана загрузки.
+        // Задача 12+05: конфиг экрана загрузки (через setLoadingConfig — единый маппинг).
         if (state.scene.loadingScreen && typeof state.scene.loadingScreen === 'object') {
-            const ls = state.scene.loadingScreen;
+            this.setLoadingConfig(state.scene.loadingScreen);
-            this._loadingConfig = {
-                logo: ls.logo || null,
-                accentColor: ls.accentColor || '#ffc020',
-                defaultSpinner: ls.defaultSpinner !== false,
-                defaultSkipButton: !!ls.defaultSkipButton,
-            };
         } else {
             this._loadingConfig = null;
         }
@@ -7565,6 +7671,11 @@ export class BabylonScene {
         if (state.scene.environment && this.environment) {
             this.environment.load(state.scene.environment);
         }
+        // Графика/эффекты (шейдеры) — применяем если автор настроил и не 'off'.
+        if (state.scene.graphics && state.scene.graphics.preset
+            && state.scene.graphics.preset !== 'off') {
+            try { this.setGraphics(state.scene.graphics); } catch (e) { /* ignore */ }
+        }
         // Кастомное небо (задача 16)
         if (state.scene.skybox && this.skybox) {
             this.skybox.load(state.scene.skybox);

src/engine/GameRuntime.js

@@ -17,6 +17,9 @@
 import { Color3 } from '@babylonjs/core';
 import { ScriptSandbox } from './ScriptSandbox';
 import { STORYS_addres } from '../api/API';
+import { handleLuaCommand, unpackRobloxLuaCode, parseRobloxLuaMeta } from './rbxl-lua-integration.js';
+import { LuaSharedSandbox } from './lua/LuaSharedSandbox.js';
+import { RbxlHudOverlay } from './RbxlHudOverlay.js';
 import { LabelManager } from './LabelManager';   // задача: scene.setLabel (require крашит в браузере)
 
 export class GameRuntime {
@@ -101,7 +104,55 @@ export class GameRuntime {
         // (на старте) возвращает null → подписки obj.onTouch/find не работают.
         let initialScene = null;
         try { initialScene = this._buildSceneSnapshot(); } catch (e) { initialScene = null; }
+        // Фаза 2 синхронизации со студией: и user-Lua (language='lua'), и
+        // импортированные .rbxl-скрипты (с маркером // @roblox-lua) теперь
+        // идут через ОДИН LuaSharedSandbox в main thread (wasmoon один раз).
+        // Снимает WASM OOM лимит и устраняет race с worker'ом.
+        const luaUserBatch = [];
+        const runImportedRbxl = !(typeof window !== 'undefined' && window.__RBXL_SKIP_IMPORTED === true);
+        let rbxlSkipped = 0;
         for (const s of scripts) {
+            // Roblox-Lua скрипты импортированные через rbxl-importer.
+            if (s && typeof s.code === 'string' && s.code.startsWith('// @roblox-lua')) {
+                if (!runImportedRbxl) { rbxlSkipped++; continue; }
+                const meta = parseRobloxLuaMeta(s.code);
+                if (meta && meta.enabled === false) { rbxlSkipped++; continue; }
+                const sname = String(s.name || '').toLowerCase();
+                if (sname.startsWith('regenerate') || sname === 'regenerationscript') {
+                    rbxlSkipped++; continue;
+                }
+                const luaSource = unpackRobloxLuaCode(s.code);
+                if (luaSource && (
+                    /while\s+not\s+\w+[:.]FindFirstChild/.test(luaSource) ||
+                    /ChildAdded:[Ww]ait\(\)/.test(luaSource) ||
+                    /:[Gg]etChildren\(\)\s*\[\d/.test(luaSource)
+                )) {
+                    rbxlSkipped++;
+                    // eslint-disable-next-line no-console
+                    console.warn(`[GameRuntime] skipped ${s.name}: tight-loop (WaitForChild/ChildAdded:wait)`);
+                    continue;
+                }
+                if (luaSource && luaSource.trim()) {
+                    let toolName = null;
+                    if (s.target == null && /(script\.Parent|Tool)\.(Equipped|Unequipped|Activated|Deactivated)/.test(luaSource)) {
+                        toolName = 'Tool';
+                    }
+                    luaUserBatch.push({
+                        id: s.id,
+                        name: s.name,
+                        target: s.target,
+                        toolName,
+                        language: 'lua',
+                        code: luaSource,
+                        _rbxlImported: true,
+                    });
+                }
+                continue;
+            }
+            if (s && s.language === 'lua') {
+                if (typeof s.code === 'string' && s.code.trim()) luaUserBatch.push(s);
+                continue;
+            }
             if (!s || typeof s.code !== 'string' || !s.code.trim()) {
                 // eslint-disable-next-line no-console
                 console.warn('[GameRuntime] skipping invalid script entry', s);
@@ -131,6 +182,132 @@ export class GameRuntime {
             // eslint-disable-next-line no-console
             console.log('[GameRuntime] sandbox started for script id=', s.id);
         }
+        // === Фаза 2: единый LuaSharedSandbox для user-Lua + импортированных .rbxl ===
+        let luaUserCount = 0;
+        if (luaUserBatch.length > 0) {
+            try {
+                const sb = new LuaSharedSandbox();
+                sb.setOnCommand(({ cmd, payload }) => {
+                    if (cmd === 'partSet' || cmd === 'partVel' ||
+                        cmd === 'sceneCreate' || cmd === 'sceneDelete') {
+                        try {
+                            handleLuaCommand(null, cmd, payload, this);
+                        } catch (e) {
+                            // eslint-disable-next-line no-console
+                            console.error('[GameRuntime] handleLuaCommand failed:', cmd, payload, e);
+                        }
+                    } else if (cmd === 'toolRegistered') {
+                        try { this._registerRbxlTool?.(payload); } catch (e) {
+                            // eslint-disable-next-line no-console
+                            console.warn('[GameRuntime] toolRegistered failed', e);
+                        }
+                    } else if (cmd === 'lightingTimeUpdate') {
+                        try {
+                            const baseHour = Number(payload?.hour);
+                            if (baseHour >= 0 && baseHour < 24) {
+                                if (this._lightBaseHour == null) {
+                                    this._lightBaseHour = baseHour;
+                                    this._lightStartReal = performance.now();
+                                }
+                                const dGame = baseHour - this._lightBaseHour;
+                                const accel = 8;
+                                const hour = ((this._lightBaseHour + dGame * accel) % 24 + 24) % 24;
+                                this.scene3d?.setTimeOfDay?.(hour);
+                                let targetPreset;
+                                if (hour >= 6 && hour < 8) targetPreset = 'sunset';
+                                else if (hour >= 8 && hour < 17) targetPreset = 'lowpoly-roblox';
+                                else if (hour >= 17 && hour < 19) targetPreset = 'sunset';
+                                else targetPreset = 'starry-night';
+                                if (this._lightPreset !== targetPreset) {
+                                    this._lightPreset = targetPreset;
+                                    try {
+                                        const sky = this.scene3d?.skybox;
+                                        if (sky?.fadeTo) sky.fadeTo({ preset: targetPreset }, 2);
+                                        else this.scene3d?.setSkybox?.({ preset: targetPreset });
+                                    } catch (_) {}
+                                }
+                            }
+                        } catch (_) {}
+                    } else if (cmd === 'particleCreated') {
+                        this._rbxlPendingParticles = this._rbxlPendingParticles || [];
+                        this._rbxlPendingParticles.push(payload);
+                    } else if (cmd === 'mouseIconChanged') {
+                        try {
+                            const canvas = this.scene3d?.engine?.getRenderingCanvas?.();
+                            if (canvas) canvas.style.cursor = payload.cssCursor || 'default';
+                        } catch (_) {}
+                    } else if (cmd === 'hudMessage') {
+                        try {
+                            this._ensureRbxlHud();
+                            if (payload.visible && payload.text) {
+                                this._rbxlHud.showMessage(payload.text);
+                            } else {
+                                this._rbxlHud.hideMessage();
+                            }
+                        } catch (_) {}
+                    } else if (cmd === 'killFeed') {
+                        try {
+                            this._ensureRbxlHud();
+                            this._rbxlHud.addKillFeed(payload.killer, payload.victim, payload.weapon);
+                        } catch (_) {}
+                    } else if (cmd === 'winShow') {
+                        try {
+                            this._ensureRbxlHud();
+                            this._rbxlHud.showWin(payload.text || 'WIN!');
+                        } catch (_) {}
+                    } else if (cmd === 'ui.showText') {
+                        try {
+                            this._ensureRbxlHud();
+                            this._rbxlHud.showMessage(payload.text || '');
+                            const dur = Number(payload.duration) || 2;
+                            const t = payload.text || '';
+                            setTimeout(() => {
+                                try {
+                                    if (this._rbxlHud._lastMessage === t) {
+                                        this._rbxlHud.hideMessage();
+                                    }
+                                } catch (_) {}
+                            }, dur * 1000);
+                            try { this._rbxlHud._lastMessage = t; } catch (_) {}
+                        } catch (_) {}
+                    } else if (cmd === 'leaderstatSet') {
+                        try {
+                            const lm = this.scene3d?.leaderstats;
+                            if (lm) {
+                                const statName = String(payload.statName || 'Stat');
+                                if (!lm._defs.some(d => d.name === statName)) {
+                                    lm.define(statName, { initial: 0 });
+                                }
+                                lm.set(lm._meId || 'me', statName, Number(payload.value) || 0);
+                            }
+                        } catch (_) {}
+                    } else {
+                        this._handleCommand(null, cmd, payload);
+                    }
+                });
+                try {
+                    const snap = this._buildSceneSnapshot();
+                    sb.sendSceneSnapshot(snap);
+                } catch (_) {}
+                for (const s of luaUserBatch) {
+                    sb.addScript(s.id, s.code, s.target, s.name, { toolName: s.toolName });
+                }
+                sb.start();
+                this.sandboxes.push(sb);
+                this._luaUserSandbox = sb;
+                luaUserCount = luaUserBatch.length;
+            } catch (e) {
+                // eslint-disable-next-line no-console
+                console.error('[GameRuntime] Lua user runtime failed to init', e);
+                this._log('error', `Lua-runtime ошибка: ${e?.message || e}`);
+            }
+        }
+        if (rbxlSkipped > 0) {
+            this._log('info', `Импортированных .rbxl-скриптов пропущено: ${rbxlSkipped}`);
+        }
+        if (luaUserCount > 0) {
+            this._log('info', `Запущено Lua-скриптов (включая .rbxl): ${luaUserCount}`);
+        }
         this._log('info', `Запущено скриптов: ${this.sandboxes.length}`);
         // Подцепляемся на изменения HP игрока, чтобы шлать событие 'hpChange'
         // во все sandbox'ы. Не перезаписываем существующий обработчик —
@@ -360,6 +537,8 @@ export class GameRuntime {
                 ls.setBridge(
                     (id) => { for (const sb of this.sandboxes) sb.sendGlobalEvent({ type: 'loadingSkip', loadingId: id }); },
                     (id) => { for (const sb of this.sandboxes) sb.sendGlobalEvent({ type: 'loadingComplete', loadingId: id }); },
+                    // Задача 05: onHide.
+                    () => { for (const sb of this.sandboxes) sb.sendGlobalEvent({ type: 'loadingHidden' }); },
                 );
                 this.scene3d.loadingScreen = ls;
             }
@@ -482,6 +661,14 @@ export class GameRuntime {
         return null;
     }
 
+    /** DOM-overlay для импортированных Roblox-карт (KillFeed/Message/WinGui). */
+    _ensureRbxlHud() {
+        if (this._rbxlHud) return;
+        const canvas = this.scene3d?.engine?.getRenderingCanvas?.();
+        const parent = canvas?.parentElement || document.body;
+        this._rbxlHud = new RbxlHudOverlay(parent);
+    }
+
     stop() {
         if (this.sandboxes.length > 0) {
             this._log('info', 'Остановка скриптов');
@@ -489,6 +676,11 @@ export class GameRuntime {
             console.log('[GameRuntime] stopping', this.sandboxes.length, 'sandboxes');
             for (const sb of this.sandboxes) sb.stop();
         }
+        // Очищаем Roblox HUD overlay (KillFeed/Message/WinGui) — Фаза 2.
+        try { this._rbxlHud?.dispose?.(); } catch (_) {}
+        this._rbxlHud = null;
+        this._rbxlPendingParticles = null;
+        this._luaUserSandbox = null;
         // Удаляем все объекты, которые скрипты наспавнили через
         // game.scene.spawn/clone — иначе после Stop они остаются на сцене
         // и накапливаются при повторных запусках.
@@ -621,7 +813,55 @@ export class GameRuntime {
     tick(dt) {
         if (!this._isRunning || this.sandboxes.length === 0) return;
         const state = this._collectState();
+        // Реальная позиция игрока для Lua __rbxl_player_pos()
+        const playerObj = this.scene3d?.player;
+        let realPos = null;
+        if (playerObj?._pos) {
+            const halfH = playerObj.HALF_H ?? 0.9;
+            realPos = { x: playerObj._pos.x, y: playerObj._pos.y - halfH, z: playerObj._pos.z };
+        } else if (state?.player) {
+            realPos = { x: state.player.x, y: state.player.y, z: state.player.z };
+        }
+        // Позиции спавненных динамических примитивов (id >= 800000)
+        let spawnedPositions = null;
+        try {
+            const pm = this.scene3d?.primitiveManager;
+            if (pm && pm.instances) {
+                for (const [id, data] of pm.instances.entries()) {
+                    if (id < 800000 || data.anchored !== false) continue;
+                    if (!spawnedPositions) spawnedPositions = [];
+                    spawnedPositions.push([id, data.x, data.y, data.z]);
+                }
+            }
+        } catch (_) {}
+        // Позиции NPC для Lua-shim
+        const npcPositions = [];
+        try {
+            const nm = this.scene3d?.npcManager;
+            if (nm && nm.npcs && this._localToReal) {
+                for (const [localRef, realRef] of this._localToReal.entries()) {
+                    if (typeof realRef !== 'string' || !realRef.startsWith('npc:')) continue;
+                    const npcId = Number(realRef.slice(4));
+                    const npc = nm.npcs.get(npcId);
+                    if (npc) npcPositions.push([localRef, npc.x, npc.y, npc.z]);
+                }
+            }
+        } catch (_) {}
         for (const sb of this.sandboxes) {
+            // Синк Lua-shim позиций (LuaSharedSandbox имеет sb.api.update*)
+            if (realPos && sb.api?.updatePlayerPos) {
+                try { sb.api.updatePlayerPos(realPos.x, realPos.y, realPos.z); } catch (_) {}
+            }
+            if (spawnedPositions && sb.api?.updateSpawnedPos) {
+                for (const [id, x, y, z] of spawnedPositions) {
+                    try { sb.api.updateSpawnedPos(id, x, y, z); } catch (_) {}
+                }
+            }
+            if (npcPositions.length > 0 && sb.api?.updateNpcPos) {
+                for (const [ref, x, y, z] of npcPositions) {
+                    try { sb.api.updateNpcPos(ref, x, y, z); } catch (_) {}
+                }
+            }
             // Для скриптов с target — добавляем актуальную позицию self
             const stateForSb = sb.target
                 ? { ...state, selfPosition: this._collectSelfPosition(sb.target) }
@@ -1742,9 +1982,9 @@ export class GameRuntime {
             if (ls && payload) {
                 try {
                     const id = ls.show(payload.opts || {});
-                    if (payload.replyId != null) {
+                    // replyId может отсутствовать (стартовый экран) — всё равно шлём
-                        for (const sb of this.sandboxes) sb.sendGlobalEvent({ type: 'loadingShown', replyId: payload.replyId, loadingId: id });
+                    // loadingShown для game.loading.isVisible() (задача 05).
-                    }
+                    for (const sb of this.sandboxes) sb.sendGlobalEvent({ type: 'loadingShown', replyId: payload.replyId, loadingId: id });
                 } catch (e) { this._log('error', 'loading.show: ' + (e?.message || e)); }
             }
             return;
@@ -1752,6 +1992,7 @@ export class GameRuntime {
         if (cmd === 'loading.setProgress') { this.scene3d?.loadingScreen?.setProgress(payload?.value); return; }
         if (cmd === 'loading.setText') { this.scene3d?.loadingScreen?.setText(payload?.text); return; }
         if (cmd === 'loading.setCover') { this.scene3d?.loadingScreen?.setCover(payload?.cover); return; }
+        if (cmd === 'loading.setBackground') { this.scene3d?.loadingScreen?.setBackground?.(payload?.background); return; }
         if (cmd === 'loading.close') { this.scene3d?.loadingScreen?.close(); return; }
 
         // === Damage Floaters (задача 40) ===
@@ -3328,6 +3569,10 @@ export class GameRuntime {
             } catch (e) {}
             return;
         }
+        if (cmd === 'graphics.set') {
+            try { this.scene3d?.setGraphics?.(payload || {}); } catch (e) {}
+            return;
+        }
         // === Задача 03: GUI tween ===
         if (cmd === 'gui.tween') {
             try {

src/engine/GraphicsManager.js

@@ -0,0 +1,328 @@
+/**
+ * GraphicsManager — система визуальных эффектов («шейдеры») для игр Рублокса.
+ *
+ * Управляет:
+ *   - постобработкой экрана через Babylon DefaultRenderingPipeline:
+ *       bloom (свечение), FXAA (сглаживание), виньетка, цветокоррекция
+ *       (контраст/насыщенность/экспозиция), тонмаппинг, глубина резкости (DoF);
+ *   - качеством теней (через scene3d.setShadowQuality);
+ *   - контактными тенями SSAO (через scene3d.setSsaoEnabled).
+ *
+ * Управляется И из настроек игры (вкладка «Графика»), И из скриптов
+ * (game.graphics.*). По умолчанию ВСЁ ВЫКЛЮЧЕНО (preset 'off') — старые игры
+ * не меняются, FPS не страдает. Автор включает осознанно.
+ *
+ * Mobile-safe: на слабых устройствах тяжёлые эффекты (DoF, SSAO, ultra-тени,
+ * HDR-bloom) автоматически урезаются, даже если в пресете включены.
+ *
+ * Один и тот же класс используется в студии и плеере (фича-парность).
+ *
+ * Использование:
+ *   const gfx = new GraphicsManager(scene, camera, scene3d, { mobile });
+ *   gfx.apply({ preset: 'cinematic' });
+ *   gfx.apply({ bloom: { enabled: true, intensity: 0.7 } });
+ *   gfx.dispose();
+ */
+import {
+    DefaultRenderingPipeline, Color4, ImageProcessingConfiguration,
+} from '@babylonjs/core';
+
+/**
+ * Именованные пресеты. Каждый — полный набор настроек. 'off' = чистая картинка
+ * (pipeline не создаётся вовсе). Значения подобраны так, чтобы быть заметными,
+ * но не «кислотными».
+ */
+export const GRAPHICS_PRESETS = {
+    off: {
+        bloom: { enabled: false },
+        fxaa: false,
+        vignette: { enabled: false },
+        grading: { enabled: false },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: null,        // null = не трогаем текущее качество теней
+    },
+    // Лёгкий: только мягкое свечение + сглаживание. Дёшево, годится почти везде.
+    low: {
+        bloom: { enabled: true, intensity: 0.3, threshold: 0.9 },
+        fxaa: true,
+        vignette: { enabled: false },
+        grading: { enabled: false },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: 'hard',
+    },
+    // Средний: свечение + лёгкая виньетка + чуть насыщенности.
+    medium: {
+        bloom: { enabled: true, intensity: 0.45, threshold: 0.85 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 0.5 },
+        grading: { enabled: true, contrast: 1.05, saturation: 1.1, exposure: 1.0 },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: 'soft',
+    },
+    // Высокий: всё кроме DoF, SSAO включён.
+    high: {
+        bloom: { enabled: true, intensity: 0.6, threshold: 0.82 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 0.6 },
+        grading: { enabled: true, contrast: 1.1, saturation: 1.2, exposure: 1.05 },
+        dof: { enabled: false },
+        ssao: true,
+        shadows: 'soft',
+    },
+    // Ультра: + глубина резкости + мягкие каскадные тени.
+    ultra: {
+        bloom: { enabled: true, intensity: 0.7, threshold: 0.8 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 0.65 },
+        grading: { enabled: true, contrast: 1.12, saturation: 1.25, exposure: 1.05 },
+        dof: { enabled: true, focusDistance: 18, focalLength: 50, aperture: 1.2 },
+        ssao: true,
+        shadows: 'high',
+    },
+    // === Стилевые пресеты (художественные) ===
+    cinematic: {
+        bloom: { enabled: true, intensity: 0.55, threshold: 0.8 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 0.85 },
+        grading: { enabled: true, contrast: 1.18, saturation: 1.05, exposure: 1.0 },
+        dof: { enabled: true, focusDistance: 22, focalLength: 60, aperture: 1.0 },
+        ssao: true,
+        shadows: 'soft',
+    },
+    vivid: {
+        bloom: { enabled: true, intensity: 0.65, threshold: 0.78 },
+        fxaa: true,
+        vignette: { enabled: false },
+        grading: { enabled: true, contrast: 1.1, saturation: 1.5, exposure: 1.1 },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: 'soft',
+    },
+    night: {
+        bloom: { enabled: true, intensity: 0.8, threshold: 0.7 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 1.0 },
+        grading: { enabled: true, contrast: 1.2, saturation: 0.85, exposure: 0.8 },
+        dof: { enabled: false },
+        ssao: true,
+        shadows: 'soft',
+    },
+    retro: {
+        bloom: { enabled: false },
+        fxaa: false,   // намеренно «пиксельно»
+        vignette: { enabled: true, weight: 1.2 },
+        grading: { enabled: true, contrast: 1.3, saturation: 0.7, exposure: 0.95 },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: 'hard',
+    },
+    soft: {
+        bloom: { enabled: true, intensity: 0.4, threshold: 0.88 },
+        fxaa: true,
+        vignette: { enabled: true, weight: 0.4 },
+        grading: { enabled: true, contrast: 0.95, saturation: 1.05, exposure: 1.05 },
+        dof: { enabled: false },
+        ssao: false,
+        shadows: 'soft',
+    },
+};
+
+// Глубокое слияние пресета и пользовательских оверрайдов.
+function _mergeConfig(base, over) {
+    const out = JSON.parse(JSON.stringify(base || {}));
+    if (!over) return out;
+    for (const k of Object.keys(over)) {
+        const v = over[k];
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            out[k] = { ...(out[k] || {}), ...v };
+        } else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+
+export class GraphicsManager {
+    /**
+     * @param scene   Babylon Scene
+     * @param camera  активная камера (для pipeline)
+     * @param scene3d ссылка на BabylonScene (для setShadowQuality / setSsaoEnabled / света)
+     * @param opts    { mobile:boolean }
+     */
+    constructor(scene, camera, scene3d, opts = {}) {
+        this.scene = scene;
+        this.camera = camera;
+        this.scene3d = scene3d;
+        this.mobile = !!opts.mobile;
+        this._pipeline = null;
+        // Текущая активная конфигурация (после merge + mobile-clamp).
+        this.config = _mergeConfig(GRAPHICS_PRESETS.off, null);
+        this.config.preset = 'off';
+        this.enabled = false;
+    }
+
+    /** Сменить камеру (например после смены режима камеры) — пересобрать pipeline. */
+    setCamera(camera) {
+        if (camera === this.camera) return;
+        this.camera = camera;
+        if (this.enabled) this._rebuildPipeline();
+    }
+
+    /**
+     * Применить настройки графики. Принимает либо {preset}, либо отдельные
+     * секции (bloom/vignette/grading/dof/ssao/fxaa/shadows), либо и то и другое
+     * (оверрайды поверх пресета). Сохраняет состояние в this.config.
+     */
+    apply(settings = {}) {
+        let cfg;
+        if (settings.preset && GRAPHICS_PRESETS[settings.preset]) {
+            cfg = _mergeConfig(GRAPHICS_PRESETS[settings.preset], settings);
+            cfg.preset = settings.preset;
+        } else {
+            // частичный апдейт поверх текущего
+            cfg = _mergeConfig(this.config, settings);
+            cfg.preset = settings.preset || this.config.preset || 'custom';
+        }
+        this.config = this._clampForMobile(cfg);
+        this._applyConfig();
+        return this.config;
+    }
+
+    /** Полностью выключить эффекты (как preset 'off'). */
+    disableAll() {
+        return this.apply({ preset: 'off' });
+    }
+
+    /** Текущая конфигурация (для serialize). */
+    serialize() {
+        // Храним «как просили» (preset + явные оверрайды). Для простоты — весь cfg.
+        return JSON.parse(JSON.stringify(this.config));
+    }
+
+    // --- внутреннее ---
+
+    /** На слабых устройствах гасим самое дорогое, что бы ни просили. */
+    _clampForMobile(cfg) {
+        if (!this.mobile) return cfg;
+        const c = JSON.parse(JSON.stringify(cfg));
+        if (c.dof) c.dof.enabled = false;       // DoF дорогой
+        c.ssao = false;                          // SSAO дорогой
+        if (c.shadows === 'high' || c.shadows === 'medium') c.shadows = 'hard';
+        // bloom оставляем, но без HDR (решается в _rebuildPipeline)
+        c._mobileClamped = true;
+        return c;
+    }
+
+    _applyConfig() {
+        const c = this.config;
+        const anyPipelineFx = (c.bloom && c.bloom.enabled) || c.fxaa
+            || (c.vignette && c.vignette.enabled) || (c.grading && c.grading.enabled)
+            || (c.dof && c.dof.enabled);
+
+        // Тени и SSAO — через scene3d (они вне pipeline).
+        try {
+            if (c.shadows && this.scene3d?.setShadowQuality) {
+                this.scene3d.setShadowQuality(c.shadows);
+            }
+        } catch (e) { /* ignore */ }
+        try {
+            if (this.scene3d?.setSsaoEnabled) this.scene3d.setSsaoEnabled(!!c.ssao);
+        } catch (e) { /* ignore */ }
+
+        if (!anyPipelineFx) {
+            this.enabled = false;
+            this._disposePipeline();
+            return;
+        }
+        this.enabled = true;
+        this._rebuildPipeline();
+    }
+
+    _rebuildPipeline() {
+        this._disposePipeline();
+        if (!this.scene || !this.camera) return;
+        const c = this.config;
+        const useHdr = (c.bloom && c.bloom.enabled) && !this.mobile;
+
+        const p = new DefaultRenderingPipeline('rbx_graphics', useHdr, this.scene, [this.camera]);
+
+        // Bloom
+        p.bloomEnabled = !!(c.bloom && c.bloom.enabled);
+        if (p.bloomEnabled) {
+            p.bloomThreshold = c.bloom.threshold ?? 0.85;
+            p.bloomWeight = c.bloom.intensity ?? 0.5;
+            p.bloomKernel = this.mobile ? 32 : 64;
+            p.bloomScale = 0.5;
+        }
+
+        // FXAA
+        p.fxaaEnabled = !!c.fxaa;
+        p.samples = this.mobile ? 1 : 4;
+
+        // Image processing: виньетка + цветокоррекция + (опц.) тонмаппинг
+        const ip = p.imageProcessing;
+        if (ip) {
+            p.imageProcessingEnabled = true;
+            ip.toneMappingEnabled = false; // как в GdPostFx — иначе картинка темнеет
+            // экспозиция/контраст из grading
+            if (c.grading && c.grading.enabled) {
+                ip.exposure = c.grading.exposure ?? 1.0;
+                ip.contrast = c.grading.contrast ?? 1.0;
+                ip.colorCurvesEnabled = true;
+                try {
+                    const curves = ip.colorCurves;
+                    if (curves) {
+                        // saturation: 1.0 = норма → curves в диапазоне примерно -100..100
+                        const sat = c.grading.saturation ?? 1.0;
+                        curves.globalSaturation = Math.round((sat - 1.0) * 60);
+                    }
+                } catch (e) { /* ignore */ }
+            } else {
+                ip.exposure = 1.0; ip.contrast = 1.0;
+            }
+            // виньетка
+            if (c.vignette && c.vignette.enabled) {
+                ip.vignetteEnabled = true;
+                ip.vignetteWeight = c.vignette.weight ?? 0.6;
+                ip.vignetteColor = new Color4(0, 0, 0, 0);
+                ip.vignetteStretch = 0.3;
+                ip.vignetteCameraFov = 0.5;
+                ip.vignetteBlendMode = ImageProcessingConfiguration.VIGNETTEMODE_MULTIPLY;
+            } else {
+                ip.vignetteEnabled = false;
+            }
+        }
+
+        // Depth of Field (глубина резкости) — только desktop
+        if (c.dof && c.dof.enabled && !this.mobile) {
+            p.depthOfFieldEnabled = true;
+            try {
+                p.depthOfFieldBlurLevel = 1; // 0..2
+                p.depthOfField.focusDistance = (c.dof.focusDistance ?? 18) * 1000; // мм
+                p.depthOfField.focalLength = c.dof.focalLength ?? 50;
+                p.depthOfField.fStop = c.dof.aperture ?? 1.2;
+            } catch (e) { /* ignore */ }
+        } else {
+            p.depthOfFieldEnabled = false;
+        }
+
+        this._pipeline = p;
+    }
+
+    _disposePipeline() {
+        if (this._pipeline) {
+            try { this._pipeline.dispose(); } catch (e) { /* ignore */ }
+            this._pipeline = null;
+        }
+    }
+
+    dispose() {
+        this._disposePipeline();
+        this.scene = null;
+        this.camera = null;
+        this.scene3d = null;
+    }
+}

src/engine/LabelManager.js

@@ -1,80 +1,385 @@
 /**
- * LabelManager — billboard-метки (текст-плашки) над 3D-объектами.
+ * LabelManager — billboard-плашки (текст-надписи) над 3D-объектами.
  *
- * Используется для game.scene.setLabel(ref, text) — имена/HP над
+ * game.scene.setLabel(ref, text, opts) — имена/HP/таймеры/счётчики над
- * персонажами, врагами, предметами. Метка всегда повёрнута лицом к камере
+ * персонажами, врагами, предметами. По умолчанию плашка повёрнута лицом к
- * (billboardMode=7), всегда поверх геометрии (renderingGroupId=1).
+ * камере (billboardMode=7), всегда поверх геометрии (renderingGroupId=1).
  *
- * Метка привязывается к мешу объекта (parent) и висит над ним.
+ * Задача 10 — расширенные стили: фон/обводка/скругление (пресеты gameui/
+ * warning/reward/boss-hp/plain), обводка текста, richText (<color>/<b>/<size>),
+ * faceMode billboard|fixed, attachPoint, maxDistance.
+ *
+ * Плашка привязывается к мешу объекта (parent) и висит над ним.
  */
 import { DynamicTexture } from '@babylonjs/core/Materials/Textures/dynamicTexture';
 import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
 import { MeshBuilder } from '@babylonjs/core/Meshes/meshBuilder';
 import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+
+// === Пресеты стилей плашки (фон/обводка/текст) ===
+// gameui — жёлтая обводка + тёмно-синий фон + белый текст (как в Roblox-UI).
+export const LABEL_PRESETS = {
+    plain: {
+        background: null, borderColor: null, borderWidth: 0, cornerRadius: 0,
+        color: '#ffffff', textStroke: { color: '#000', width: 8 },
+    },
+    gameui: {
+        background: '#1a3a8a', borderColor: '#f5c020', borderWidth: 10, cornerRadius: 28,
+        color: '#ffffff', textStroke: { color: '#0a1430', width: 6 },
+    },
+    warning: {
+        background: '#b01e1e', borderColor: '#ffce3a', borderWidth: 10, cornerRadius: 28,
+        color: '#ffffff', textStroke: { color: '#000', width: 6 },
+    },
+    reward: {
+        background: '#caa018', borderColor: '#fff0a0', borderWidth: 10, cornerRadius: 28,
+        color: '#fff8e0', textStroke: { color: '#6b4e00', width: 6 },
+        gradient: ['#f7d34a', '#c98a18'],   // золотой градиент фона
+    },
+    'boss-hp': {
+        background: '#3a0a0a', borderColor: '#ff4040', borderWidth: 8, cornerRadius: 20,
+        color: '#ffd0d0', textStroke: { color: '#000', width: 6 },
+        gradient: ['#8a1414', '#3a0a0a'],
+    },
+};
 
 export class LabelManager {
     constructor(scene) {
         this.scene = scene;
-        // ref-строка объекта → { plane, tex, mat }
+        // ref-строка объекта → { plane, tex, mat, lastKey, opts }
         this.labels = new Map();
+        this._playerMesh = null;   // для maxDistance — задаётся из BabylonScene
     }
 
+    /** Дать ссылку на меш игрока (для maxDistance-скрытия). */
+    setPlayerMesh(mesh) { this._playerMesh = mesh; }
+
     /**
-     * Установить/обновить метку над объектом.
+     * Установить/обновить плашку над объектом.
-     *   ref      — ref-строка объекта (от scene.spawn / scene.find).
+     *   ref        — ref-строка объекта.
-     *   anchorMesh — Babylon-меш объекта (метка крепится к нему).
+     *   anchorMesh — Babylon-меш объекта (плашка крепится к нему).
-     *   text     — текст метки.
+     *   text       — текст (может содержать richText-теги если opts.richText).
-     *   opts     — { color: '#fff', height: 2.5 (м над объектом), size: 1 }
+     *   opts       — см. LABEL_PRESETS + { color, height, size, background,
+     *                borderColor, borderWidth, cornerRadius, padding, textStroke,
+     *                fontWeight, faceMode, rotationY, attachPoint, preset,
+     *                richText, maxDistance }
      */
     setLabel(ref, anchorMesh, text, opts = {}) {
         if (!anchorMesh) return;
-        const color = opts.color || '#ffffff';
+        text = String(text == null ? '' : text);
+
+        // Пресет → база, поверх — явные opts.
+        const preset = opts.preset && LABEL_PRESETS[opts.preset] ? LABEL_PRESETS[opts.preset] : null;
+        const st = { ...(preset || {}), ...opts };
+        const color = st.color || '#ffffff';
         const heightAbove = Number.isFinite(opts.height) ? opts.height : 2.5;
         const sizeMul = Number.isFinite(opts.size) ? opts.size : 1;
+        const richText = !!opts.richText;
+
+        // Диф-чек: если ничего не поменялось — не пересоздаём (важно для bindLabel).
+        const styleKey = JSON.stringify({ text, color, preset: opts.preset, bg: st.background,
+            bc: st.borderColor, bw: st.borderWidth, cr: st.cornerRadius, rich: richText,
+            fw: st.fontWeight, h: heightAbove, sz: sizeMul, fm: st.faceMode, ry: st.rotationY,
+            af: st.attachFace, tl: st.tilt, ap: typeof st.attachPoint === 'string' ? st.attachPoint : null });
+        const existing = this.labels.get(ref);
+        if (existing && existing.lastKey === styleKey && existing.plane.parent === anchorMesh) {
+            return; // ничего не изменилось
+        }
+
+        // Меняется только текст (тот же стиль/размер) → перерисуем canvas без
+        // пересоздания меша (дешевле). Иначе — полное пересоздание.
+        const sameStruct = existing && existing.styleStruct === this._structKey(st, richText, heightAbove, sizeMul);
+        if (sameStruct) {
+            this._drawCanvas(existing.tex, text, color, st, richText);
+            existing.tex.update(true);
+            existing.lastKey = styleKey;
+            existing.lastText = text;
+            return;
+        }
 
-        // Если метка уже есть — пересоздаём (текст/цвет могли измениться).
         this.clearLabel(ref);
 
+        // Размер текстуры: чем больше текста — тем шире, чтобы не растягивать.
+        const fontPx = 120;
         const W = 1024, H = 256;
-        const tex = new DynamicTexture(`lblTex_${ref}_${Date.now()}`,
+        const tex = new DynamicTexture(`lblTex_${ref}_${this._uid()}`,
             { width: W, height: H }, this.scene, true);
         tex.updateSamplingMode?.(3);   // TRILINEAR
         tex.anisotropicFilteringLevel = 8;
-        const ctx = tex.getContext();
-        ctx.clearRect(0, 0, W, H);
-        ctx.font = 'bold 120px "Roboto Condensed", "Segoe UI", sans-serif';
-        ctx.textAlign = 'center';
-        ctx.textBaseline = 'middle';
-        ctx.lineWidth = 16;
-        ctx.lineJoin = 'round';
-        ctx.strokeStyle = '#000';
-        ctx.strokeText(String(text), W / 2, H / 2);
-        ctx.fillStyle = color;
-        ctx.fillText(String(text), W / 2, H / 2);
-        tex.update(true);
         tex.hasAlpha = true;
+        this._drawCanvas(tex, text, color, st, richText);
+        tex.update(true);
 
+        // Соотношение плашки — 4:1 (1024×256). Крупная и читаемая (как в Roblox).
+        // ОДНОСТОРОННЯЯ плоскость (FRONTSIDE): лицо = нормаль +Z. Мы всегда
+        // разворачиваем плашку лицом к наблюдателю снаружи грани, поэтому текст
+        // читается прямо. DOUBLESIDE НЕ используем — задняя грань зеркалит UV
+        // (баг: «Ключ от тайника» наоборот). backFaceCulling выключен только
+        // чтобы плашка не пропадала при взгляде сзади (без отражённого текста).
         const plane = MeshBuilder.CreatePlane(`lbl_${ref}`,
-            { width: 2.2 * sizeMul, height: 0.55 * sizeMul }, this.scene);
+            { width: 3.4 * sizeMul, height: 0.85 * sizeMul,
+              sideOrientation: Mesh.FRONTSIDE }, this.scene);
         const mat = new StandardMaterial(`lblMat_${ref}`, this.scene);
         mat.diffuseTexture = tex;
         mat.diffuseTexture.hasAlpha = true;
         mat.emissiveColor = new Color3(1, 1, 1);
+        mat.diffuseColor = new Color3(0, 0, 0);
         mat.disableLighting = true;
+        // Геометрия двусторонняя (DOUBLESIDE) с прямыми backUVs — culling можно
+        // включить, дублей нет; текст читается с обеих сторон без зеркала.
         mat.backFaceCulling = false;
         mat.disableDepthWrite = true;
+        mat.useAlphaFromDiffuseTexture = true;
         plane.material = mat;
-        plane.billboardMode = 7;        // всегда лицом к камере
+        plane.renderingGroupId = 1;
-        plane.renderingGroupId = 1;     // поверх геометрии
         plane.isPickable = false;
-        // Крепим к объекту: метка висит над ним и двигается вместе с ним.
         plane.parent = anchorMesh;
-        plane.position.set(0, heightAbove, 0);
 
-        this.labels.set(ref, { plane, tex, mat });
+        // Полуразмеры объекта по каждой оси (для крепления над верхом ИЛИ на
+        // грань). Берём bounding box в ЛОКАЛЬНЫХ координатах меша (min/max), чтобы
+        // позиция плашки-ребёнка была верной при любом масштабе/вращении родителя.
+        let halfX = 0.5, halfY = 0.5, halfZ = 0.5;
+        try {
+            const bb = anchorMesh.getBoundingInfo?.().boundingBox;
+            if (bb && bb.minimum && bb.maximum) {
+                halfX = (bb.maximum.x - bb.minimum.x) / 2;
+                halfY = (bb.maximum.y - bb.minimum.y) / 2;
+                halfZ = (bb.maximum.z - bb.minimum.z) / 2;
+            } else if (anchorMesh.scaling) {
+                halfX = Math.abs(anchorMesh.scaling.x) / 2;
+                halfY = Math.abs(anchorMesh.scaling.y) / 2;
+                halfZ = Math.abs(anchorMesh.scaling.z) / 2;
+            }
+        } catch (e) { /* ignore */ }
+        const halfH = halfY;
+        const halfPlane = 0.45 * sizeMul;   // полувысота самой плашки (3.4×0.85)
+
+        // attachFace — ПРИКРЕПИТЬ плашку НА ГРАНЬ объекта (как табличка на
+        // стене/полу): плашка лежит В ПЛОСКОСТИ грани, фиксированной ориентации,
+        // и перемещается/вращается ВМЕСТЕ с объектом (она его ребёнок). Это
+        // Roblox-style «надпись = часть постройки» (в отличие от billboard над
+        // верхом). Значения: 'top'|'bottom'|'front'|'back'|'left'|'right'
+        // (или сырые '+y'/'-y'/'+z'/'-z'/'+x'/'-x').
+        const FACE = { top: '+y', bottom: '-y', front: '+z', back: '-z',
+            right: '+x', left: '-x' };
+        let face = st.attachFace;
+        if (face && FACE[face]) face = FACE[face];
+
+        if (face) {
+            // На грань — всегда фиксированная ориентация (не billboard), иначе
+            // «связки с примитивом» не будет (плашка крутилась бы к камере).
+            plane.billboardMode = 0;
+            const gap = Number.isFinite(opts.height) ? opts.height : 0.05;
+            // ВАЖНО: Babylon CreatePlane (FRONTSIDE) лицевой стороной (где UV/текст
+            // не зеркалятся) смотрит в −Z. Поэтому чтобы ЛИЦО таблички смотрело
+            // НАРУЖУ выбранной грани, поворачиваем плоскость так, чтобы её −Z
+            // совпал с внешней нормалью грани. tiltSign — знак наклона tilt с
+            // учётом того, что для грани +z плоскость развёрнута на π.
+            let tiltSign = 1;
+            if (face === '+z')      { plane.position.set(0, 0,  halfZ + gap); plane.rotation.set(0, Math.PI, 0); tiltSign = -1; }
+            else if (face === '-z') { plane.position.set(0, 0, -(halfZ + gap)); plane.rotation.set(0, 0, 0); }
+            else if (face === '+x') { plane.position.set( halfX + gap, 0, 0); plane.rotation.set(0, -Math.PI / 2, 0); }
+            else if (face === '-x') { plane.position.set(-(halfX + gap), 0, 0); plane.rotation.set(0,  Math.PI / 2, 0); }
+            else if (face === '+y') { plane.position.set(0,  halfY + gap, 0); plane.rotation.set( Math.PI / 2, 0, 0); }
+            else if (face === '-y') { plane.position.set(0, -(halfY + gap), 0); plane.rotation.set(-Math.PI / 2, 0, 0); }
+            if (Number.isFinite(st.rotationY)) plane.rotation.y += st.rotationY;
+            // tilt — наклон таблички вокруг локальной X (ценник под ~45°, как на
+            // витрине Roblox). Знак нормализуем (tiltSign), чтобы «верх назад» был
+            // одинаковым для всех граней. Отрицательный tilt = верх отклоняется
+            // назад (от наблюдателя), как пюпитр.
+            if (Number.isFinite(st.tilt)) plane.rotation.x += st.tilt * tiltSign;
+        } else {
+            // faceMode: 'fixed' — фиксированная ориентация (вращается с объектом),
+            // но позиционируется как обычная плашка (над верхом/центром/низом).
+            if (st.faceMode === 'fixed') {
+                plane.billboardMode = 0;
+                if (Number.isFinite(st.rotationY)) plane.rotation.y = st.rotationY;
+            } else {
+                plane.billboardMode = 7;     // всегда лицом к камере
+            }
+            // attachPoint: 'top'(default) — над верхом + небольшой зазор (height);
+            // 'center' — по центру; 'bottom' — у низа; {x,y,z} — явно.
+            const gap = Number.isFinite(opts.height) ? opts.height : 0.6;
+            let py = halfH + gap + halfPlane;   // верх объекта + зазор + полувысота плашки
+            if (st.attachPoint === 'center') py = 0;
+            else if (st.attachPoint === 'bottom') py = -(halfH + gap);
+            else if (st.attachPoint && typeof st.attachPoint === 'object') {
+                plane.position.set(st.attachPoint.x || 0, st.attachPoint.y || 0, st.attachPoint.z || 0);
+                py = null;
+            }
+            if (py !== null) plane.position.set(0, py, 0);
+        }
+
+        this.labels.set(ref, {
+            plane, tex, mat,
+            lastKey: styleKey,
+            lastText: text,
+            styleStruct: this._structKey(st, richText, heightAbove, sizeMul),
+            maxDistance: Number.isFinite(opts.maxDistance) ? opts.maxDistance : null,
+        });
     }
 
-    /** Убрать метку с объекта. */
+    /** Ключ «структуры» (всё кроме текста) — для решения перерисовать ли canvas. */
+    _structKey(st, richText, h, sz) {
+        return JSON.stringify({ p: st.preset, bg: st.background, bc: st.borderColor,
+            bw: st.borderWidth, cr: st.cornerRadius, rich: richText, fw: st.fontWeight,
+            grad: st.gradient, ts: st.textStroke, h, sz, fm: st.faceMode,
+            af: st.attachFace, tl: st.tilt, ap: typeof st.attachPoint === 'string' ? st.attachPoint : null });
+    }
+
+    _uid() { this._seq = (this._seq || 0) + 1; return this._seq; }
+
+    /**
+     * Нарисовать плашку на canvas DynamicTexture.
+     * Фон (roundRect + gradient/fill) → обводка border → текст (с обводкой).
+     */
+    _drawCanvas(tex, text, color, st, richText) {
+        const W = 1024, H = 256;
+        const ctx = tex.getContext();
+        ctx.clearRect(0, 0, W, H);
+
+        const hasBg = !!st.background || (Array.isArray(st.gradient) && st.gradient.length === 2);
+        const pad = Number.isFinite(st.padding) ? st.padding : 28;
+        const cr = Number.isFinite(st.cornerRadius) ? st.cornerRadius : 0;
+        const bw = Number.isFinite(st.borderWidth) ? st.borderWidth : 0;
+
+        const weight = st.fontWeight || 700;
+        const innerPad = (hasBg ? (bw + pad) : 24);   // отступ от краёв (под рамку)
+        const maxTextW = W - innerPad * 2;
+        // Auto-fit: подбираем размер шрифта, чтобы текст влез по ширине (не обрезался).
+        let fontPx = 120;
+        if (!richText) {
+            ctx.font = `${weight} ${fontPx}px "Roboto Condensed", "Segoe UI", sans-serif`;
+            const tw = ctx.measureText(text).width;
+            if (tw > maxTextW) fontPx = Math.max(40, Math.floor(fontPx * maxTextW / tw));
+        }
+        ctx.font = `${weight} ${fontPx}px "Roboto Condensed", "Segoe UI", sans-serif`;
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+
+        // === Фон-плашка ===
+        if (hasBg) {
+            const m = bw / 2 + 4;          // отступ рамки от края текстуры
+            const x = m, y = m, w = W - m * 2, h = H - m * 2;
+            this._roundRectPath(ctx, x, y, w, h, cr);
+            if (Array.isArray(st.gradient) && st.gradient.length === 2) {
+                const g = ctx.createLinearGradient(0, y, 0, y + h);
+                g.addColorStop(0, st.gradient[0]);
+                g.addColorStop(1, st.gradient[1]);
+                ctx.fillStyle = g;
+            } else {
+                ctx.fillStyle = st.background;
+            }
+            ctx.globalAlpha = Number.isFinite(st.backgroundOpacity) ? st.backgroundOpacity : 0.92;
+            ctx.fill();
+            ctx.globalAlpha = 1;
+            if (bw > 0 && st.borderColor) {
+                ctx.lineWidth = bw;
+                ctx.strokeStyle = st.borderColor;
+                ctx.stroke();
+            }
+        }
+
+        // === Текст ===
+        const ts = st.textStroke || { color: '#000', width: hasBg ? 6 : 10 };
+        if (richText) {
+            this._drawRichText(ctx, text, color, ts, W, H);
+        } else {
+            if (ts && ts.width > 0) {
+                ctx.lineWidth = ts.width;
+                ctx.lineJoin = 'round';
+                ctx.strokeStyle = ts.color || '#000';
+                ctx.strokeText(text, W / 2, H / 2 + 4);
+            }
+            ctx.fillStyle = color;
+            ctx.fillText(text, W / 2, H / 2 + 4);
+        }
+    }
+
+    /** Путь скруглённого прямоугольника (roundRect не везде есть). */
+    _roundRectPath(ctx, x, y, w, h, r) {
+        r = Math.min(r, w / 2, h / 2);
+        ctx.beginPath();
+        ctx.moveTo(x + r, y);
+        ctx.arcTo(x + w, y, x + w, y + h, r);
+        ctx.arcTo(x + w, y + h, x, y + h, r);
+        ctx.arcTo(x, y + h, x, y, r);
+        ctx.arcTo(x, y, x + w, y, r);
+        ctx.closePath();
+    }
+
+    /**
+     * RichText: парсим теги <color=#hex>...</color>, <b>...</b>, <size=N>...</size>.
+     * Рисуем сегментами по горизонтали, центрируя всю строку. Вложенность не
+     * поддерживается (на MVP) — берём последний открытый тег каждого типа.
+     */
+    _drawRichText(ctx, text, baseColor, ts, W, H) {
+        const segs = this._parseRich(text, baseColor);
+        const fontPx = 120;
+        // Замер ширины каждого сегмента в его размере.
+        let total = 0;
+        for (const s of segs) {
+            ctx.font = `${s.bold ? 800 : 700} ${Math.round(fontPx * s.sizeMul)}px "Roboto Condensed","Segoe UI",sans-serif`;
+            s.w = ctx.measureText(s.text).width;
+            total += s.w;
+        }
+        let x = (W - total) / 2;
+        for (const s of segs) {
+            ctx.font = `${s.bold ? 800 : 700} ${Math.round(fontPx * s.sizeMul)}px "Roboto Condensed","Segoe UI",sans-serif`;
+            ctx.textAlign = 'left';
+            if (ts && ts.width > 0) {
+                ctx.lineWidth = ts.width;
+                ctx.lineJoin = 'round';
+                ctx.strokeStyle = ts.color || '#000';
+                ctx.strokeText(s.text, x, H / 2 + 4);
+            }
+            ctx.fillStyle = s.color;
+            ctx.fillText(s.text, x, H / 2 + 4);
+            x += s.w;
+        }
+        ctx.textAlign = 'center';
+    }
+
+    /** Простой парсер richText → [{text, color, bold, sizeMul}]. */
+    _parseRich(text, baseColor) {
+        const segs = [];
+        let color = baseColor, bold = false, sizeMul = 1;
+        // Разбиваем по тегам (открывающим/закрывающим).
+        const re = /<(\/?)(?:(color)=([#0-9a-fA-F]+)|(b)|(i)|(size)=(\d+))>|([^<]+)/g;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const closing = m[1] === '/';
+            if (m[8] != null) {
+                // текстовый кусок
+                if (m[8]) segs.push({ text: m[8], color, bold, sizeMul });
+            } else if (m[2]) {            // <color=...>
+                color = closing ? baseColor : m[3];
+            } else if (m[4]) {            // <b>
+                bold = !closing;
+            } else if (m[6]) {            // <size=N>
+                sizeMul = closing ? 1 : Math.max(0.4, Math.min(2, Number(m[7]) / 100));
+            }
+            // <i> игнорим визуально (italic в canvas через font-style — опускаем на MVP)
+        }
+        if (segs.length === 0) segs.push({ text: '', color: baseColor, bold: false, sizeMul: 1 });
+        return segs;
+    }
+
+    /** Каждый кадр: maxDistance-скрытие плашек дальше порога от игрока. */
+    update() {
+        if (!this._playerMesh) return;
+        const pp = this._playerMesh.position;
+        for (const rec of this.labels.values()) {
+            if (rec.maxDistance == null) continue;
+            const ap = rec.plane.getAbsolutePosition();
+            const dx = ap.x - pp.x, dy = ap.y - pp.y, dz = ap.z - pp.z;
+            const far = (dx * dx + dy * dy + dz * dz) > rec.maxDistance * rec.maxDistance;
+            rec.plane.setEnabled(!far);
+        }
+    }
+
+    /** Убрать плашку с объекта. */
     clearLabel(ref) {
         const rec = this.labels.get(ref);
         if (!rec) return;
@@ -84,7 +389,7 @@ export class LabelManager {
         this.labels.delete(ref);
     }
 
-    /** Удалить все метки (при выходе из Play). */
+    /** Удалить все плашки (при выходе из Play). */
     clearAll() {
         for (const ref of [...this.labels.keys()]) this.clearLabel(ref);
     }

src/engine/LoadingScreenOverlay.js

@@ -35,7 +35,25 @@ function injectSpinnerCss() {
         style.textContent =
             '@keyframes kbn-ls-spin{from{transform:rotate(0)}to{transform:rotate(360deg)}}' +
             '.kbn-ls-spinner{animation:kbn-ls-spin 0.9s linear infinite}' +
-            '@media (prefers-reduced-motion:reduce){.kbn-ls-spinner{animation:none}}';
+            // Ken Burns — медленный pan+zoom фона (задача 05).
+            '@keyframes kbn-ls-kenburns{' +
+            '0%{transform:scale(1.0) translate3d(0,0,0)}' +
+            '50%{transform:scale(1.10) translate3d(-3%,-2%,0)}' +
+            '100%{transform:scale(1.0) translate3d(-6%,0,0)}}' +
+            '.kbn-ls-kenburns{animation:kbn-ls-kenburns 24s ease-in-out infinite}' +
+            // particles — медленно всплывающие искры.
+            '@keyframes kbn-ls-rise{' +
+            '0%{transform:translateY(0) scale(1);opacity:0}' +
+            '10%{opacity:0.9}' +
+            '90%{opacity:0.7}' +
+            '100%{transform:translateY(-110vh) scale(1.4);opacity:0}}' +
+            '.kbn-ls-particle{animation:kbn-ls-rise linear infinite}' +
+            // лёгкий «дыхательный» glow карточки-превью.
+            '@keyframes kbn-ls-cardglow{' +
+            '0%,100%{box-shadow:0 18px 60px rgba(0,0,0,0.6),0 0 0 rgba(120,160,255,0)}' +
+            '50%{box-shadow:0 18px 60px rgba(0,0,0,0.6),0 0 40px rgba(120,160,255,0.35)}}' +
+            '.kbn-ls-cardglow{animation:kbn-ls-cardglow 4s ease-in-out infinite}' +
+            '@media (prefers-reduced-motion:reduce){.kbn-ls-spinner,.kbn-ls-kenburns,.kbn-ls-particle,.kbn-ls-cardglow{animation:none}}';
         document.head.appendChild(style);
     } catch { /* ignore */ }
 }
@@ -49,14 +67,17 @@ export class LoadingScreenOverlay {
         // Мост наружу (GameRuntime подписывает) — id-based колбэки.
         this._onSkipCb = null;       // (id) => void
         this._onCompleteCb = null;   // (id) => void
+        this._onHideCb = null;       // () => void — задача 05 (game.loading.onHide)
+        this._parallaxHandler = null;
         // DOM-ссылки активного экрана:
         this._els = null;
     }
 
     /** Колбэки-мост к GameRuntime (он рассылает globalEvent в sandbox'ы). */
-    setBridge(onSkip, onComplete) {
+    setBridge(onSkip, onComplete, onHide) {
         this._onSkipCb = onSkip;
         this._onCompleteCb = onComplete;
+        if (onHide) this._onHideCb = onHide;
     }
 
     /** Конфиг проекта (логотип/акцент по умолчанию) из BabylonScene._loadingConfig. */
@@ -104,6 +125,15 @@ export class LoadingScreenOverlay {
             logoCornerRadius: opts.logoCornerRadius != null ? Number(opts.logoCornerRadius) : 12,
             // Текст под картинкой
             text: opts.text != null ? String(opts.text) : '',
+            // --- Задача 05: Ken-Burns фон + карточка места ---
+            // style: 'ken-burns' | 'static' | 'parallax' | 'particles'
+            style: opts.style || cfg.style || 'ken-burns',
+            // фоновое размытое изображение (на весь экран); резолвится в _resolveCover.
+            background: opts.background != null ? opts.background : (cfg.background || null),
+            // карточка-витрина по центру (название места + автор), как в Roblox.
+            placeName: opts.placeName != null ? String(opts.placeName) : (cfg.placeName || ''),
+            studioName: opts.studioName != null ? String(opts.studioName) : (cfg.studioName || ''),
+            verified: opts.verified != null ? !!opts.verified : !!cfg.verified,
             // Поведение
             blockInput: opts.blockInput !== false,
             pauseSimulation: opts.pauseSimulation !== false,
@@ -163,20 +193,107 @@ export class LoadingScreenOverlay {
         // (используем opacity всего root для fade, а bgOpacity — через rgba фон):
         root.style.background = this._bgRgba(st.bgColor, st.bgOpacity);
 
-        // --- Cover (картинка по центру) ---
+        // --- Фоновый слой (Ken Burns / parallax / static) ---
-        const coverUrl = this._resolveCover(cover);
+        // Размытое изображение игры на весь экран. Отдельный div под контентом,
-        const coverImg = document.createElement('div');
+        // чтобы blur/анимация не трогали карточку и текст.
-        coverImg.style.cssText =
+        const bgUrl = this._resolveCover(st.background);
-            'max-width:min(62vw,860px);width:62vw;aspect-ratio:16/9;border-radius:16px;' +
+        const bgLayer = document.createElement('div');
-            'box-shadow:0 18px 60px rgba(0,0,0,0.6);background-size:cover;background-position:center;' +
+        let bgClass = '';
-            'background-color:#1a1f2b;margin-bottom:140px;';
+        if (bgUrl) {
-        if (coverUrl) coverImg.style.backgroundImage = `url("${coverUrl}")`;
+            if (st.style === 'ken-burns') bgClass = 'kbn-ls-kenburns';
+            bgLayer.className = bgClass;
+            bgLayer.style.cssText =
+                'position:absolute;inset:-8%;z-index:0;background-size:cover;background-position:center;' +
+                'filter:blur(8px) brightness(0.55);will-change:transform;' +
+                `background-image:url("${bgUrl}");`;
+            // parallax — лёгкий сдвиг по мыши (2 слоя имитируем одним + transform).
+            if (st.style === 'parallax') {
+                bgLayer.style.transition = 'transform 0.25s ease-out';
+                this._parallaxHandler = (e) => {
+                    const cx = (e.clientX / window.innerWidth - 0.5) * 28;
+                    const cy = (e.clientY / window.innerHeight - 0.5) * 18;
+                    bgLayer.style.transform = `translate3d(${-cx}px,${-cy}px,0) scale(1.06)`;
+                };
+                window.addEventListener('mousemove', this._parallaxHandler);
+            }
+            root.appendChild(bgLayer);
+        }
 
-        // --- Текст под картинкой ---
+        // --- particles слой (медленные искры) ---
+        if (st.style === 'particles') {
+            const pLayer = document.createElement('div');
+            pLayer.style.cssText = 'position:absolute;inset:0;z-index:1;overflow:hidden;pointer-events:none;';
+            for (let i = 0; i < 26; i++) {
+                const sp = document.createElement('span');
+                sp.className = 'kbn-ls-particle';
+                const size = 2 + Math.round(Math.random() * 4);
+                const dur = 7 + Math.random() * 10;
+                sp.style.cssText =
+                    `position:absolute;bottom:-10px;left:${(Math.random() * 100).toFixed(1)}%;` +
+                    `width:${size}px;height:${size}px;border-radius:50%;` +
+                    `background:rgba(${180 + Math.round(Math.random() * 70)},${190 + Math.round(Math.random() * 60)},255,0.85);` +
+                    `box-shadow:0 0 ${size * 2}px rgba(140,170,255,0.7);` +
+                    `animation-duration:${dur.toFixed(1)}s;animation-delay:${(-Math.random() * dur).toFixed(1)}s;`;
+                pLayer.appendChild(sp);
+            }
+            root.appendChild(pLayer);
+        }
+
+        // Обёртка контента (над фоном).
+        const content = document.createElement('div');
+        content.style.cssText =
+            'position:relative;z-index:2;display:flex;flex-direction:column;align-items:center;justify-content:center;width:100%;height:100%;';
+
+        // --- Cover (картинка-карточка по центру) ---
+        const coverUrl = this._resolveCover(cover);
+        // Режим карточки места (задача 05): квадрат + название + автор под ней.
+        const hasPlaceCard = !!(st.placeName || st.studioName);
+        const coverImg = document.createElement('div');
+        if (hasPlaceCard) {
+            coverImg.className = 'kbn-ls-cardglow';
+            coverImg.style.cssText =
+                'width:min(42vw,400px);aspect-ratio:1/1;border-radius:18px;' +
+                'background-size:cover;background-position:center;background-color:#1a1f2b;' +
+                'border:2px solid rgba(255,255,255,0.12);';
+        } else {
+            coverImg.style.cssText =
+                'max-width:min(62vw,860px);width:62vw;aspect-ratio:16/9;border-radius:16px;' +
+                'box-shadow:0 18px 60px rgba(0,0,0,0.6);background-size:cover;background-position:center;' +
+                'background-color:#1a1f2b;margin-bottom:140px;';
+        }
+        if (coverUrl) coverImg.style.backgroundImage = `url("${coverUrl}")`;
+        else if (bgUrl && hasPlaceCard) coverImg.style.backgroundImage = `url("${bgUrl}")`;
+
+        // --- Название места (крупный белый, под карточкой) ---
+        const placeEl = document.createElement('div');
+        placeEl.style.cssText =
+            'margin-top:22px;color:#fff;font-size:38px;font-weight:800;letter-spacing:0.5px;' +
+            'text-align:center;text-shadow:0 3px 14px rgba(0,0,0,0.7);' +
+            (st.placeName ? '' : 'display:none;');
+        placeEl.textContent = st.placeName || '';
+
+        // --- Автор + verified-галочка ---
+        const studioRow = document.createElement('div');
+        studioRow.style.cssText =
+            'margin-top:8px;display:flex;align-items:center;gap:7px;' +
+            'color:#cdd6e6;font-size:16px;font-weight:600;text-shadow:0 1px 4px rgba(0,0,0,0.6);' +
+            (st.studioName ? '' : 'display:none;');
+        const studioTxt = document.createElement('span');
+        studioTxt.textContent = st.studioName || '';
+        studioRow.appendChild(studioTxt);
+        if (st.verified) studioRow.appendChild(this._buildVerifiedBadge());
+
+        // --- Текст под картинкой (для не-карточного режима / mid-game) ---
         const textEl = document.createElement('div');
-        textEl.style.cssText =
+        if (hasPlaceCard) {
-            'position:absolute;left:50%;transform:translateX(-50%);bottom:170px;' +
+            textEl.style.cssText =
-            'color:#e8edf5;font-size:18px;font-weight:500;text-align:center;text-shadow:0 1px 3px rgba(0,0,0,0.6);';
+                'margin-top:14px;color:#e8edf5;font-size:16px;font-weight:500;text-align:center;' +
+                'text-shadow:0 1px 3px rgba(0,0,0,0.6);' + (st.text ? '' : 'display:none;');
+        } else {
+            textEl.style.cssText =
+                'position:absolute;left:50%;transform:translateX(-50%);bottom:170px;' +
+                'color:#e8edf5;font-size:18px;font-weight:500;text-align:center;text-shadow:0 1px 3px rgba(0,0,0,0.6);';
+        }
         textEl.textContent = st.text || '';
 
         // --- Прогресс-бар ---
@@ -245,8 +362,13 @@ export class LoadingScreenOverlay {
         spinWrap.appendChild(spinTxt);
         spinWrap.appendChild(spinCircle);
 
-        root.appendChild(coverImg);
+        // Центральная композиция (карточка + название + автор + текст) — в content.
-        root.appendChild(textEl);
+        content.appendChild(coverImg);
+        content.appendChild(placeEl);
+        content.appendChild(studioRow);
+        content.appendChild(textEl);
+        root.appendChild(content);
+        // Нижние/угловые элементы — абсолютно на root (поверх фона, рядом с content).
         root.appendChild(barWrap);
         root.appendChild(percent);
         root.appendChild(skipBtn);
@@ -255,7 +377,19 @@ export class LoadingScreenOverlay {
         parent.appendChild(root);
 
         this.root = root;
-        this._els = { root, coverImg, textEl, barWrap, bar, percent, skipBtn, logo, spinWrap };
+        this._els = { root, content, coverImg, placeEl, studioRow, textEl, barWrap, bar, percent, skipBtn, logo, spinWrap };
+    }
+
+    /** Verified-галочка (синий круг + белый чек) — inline SVG, без emoji-шрифта. */
+    _buildVerifiedBadge() {
+        const wrap = document.createElement('span');
+        wrap.style.cssText = 'display:inline-flex;align-items:center;';
+        wrap.innerHTML =
+            '<svg width="18" height="18" viewBox="0 0 24 24" aria-label="verified">' +
+            '<circle cx="12" cy="12" r="11" fill="#3897f0"/>' +
+            '<path d="M7 12.5l3 3 7-7" fill="none" stroke="#fff" stroke-width="2.4" ' +
+            'stroke-linecap="round" stroke-linejoin="round"/></svg>';
+        return wrap;
     }
 
     /** tick — fade-фазы, авто-duration, появление кнопки Пропустить. */
@@ -329,6 +463,23 @@ export class LoadingScreenOverlay {
         if (url) this._els.coverImg.style.backgroundImage = `url("${url}")`;
     }
 
+    /** Задача 05: сменить фоновое (Ken-Burns) изображение на лету. */
+    setBackground(bg) {
+        if (!this._st || !this._els) return;
+        const url = this._resolveCover(bg);
+        if (!url) return;
+        this._st.background = bg;
+        // фоновый слой — первый ребёнок root с background-image; найдём его.
+        const layer = this._els.root.querySelector('.kbn-ls-kenburns')
+            || this._els.root.firstElementChild;
+        if (layer && layer !== this._els.content) layer.style.backgroundImage = `url("${url}")`;
+    }
+
+    /** Задача 05: виден ли экран сейчас. */
+    isVisible() {
+        return !!(this._st && this._st.phase !== 'out');
+    }
+
     /** Закрыть программно (с fadeOut). */
     close() {
         const st = this._st;
@@ -361,6 +512,13 @@ export class LoadingScreenOverlay {
             if (st.blockInput) { try { this.s.player?.setInputBlocked?.(false); } catch { /* ignore */ } }
             if (st.pauseSimulation && this.s.gameRuntime) { try { this.s.gameRuntime.paused = false; } catch { /* ignore */ } }
         }
+        // Снять parallax-listener (задача 05).
+        if (this._parallaxHandler) {
+            try { window.removeEventListener('mousemove', this._parallaxHandler); } catch { /* ignore */ }
+            this._parallaxHandler = null;
+        }
+        // onHide-мост (задача 05) — сообщаем скриптам что экран скрылся.
+        if (this._onHideCb) { try { this._onHideCb(); } catch { /* ignore */ } }
         if (this.root) { try { this.root.remove(); } catch { /* ignore */ } }
         this.root = null;
         this._els = null;

src/engine/MultiplayerSync.js

@@ -137,9 +137,16 @@ export class MultiplayerSync {
         // 1. Подписки на state
         const $ = getStateCallbacks(this.room);
 
+        // Защита от повторного срабатывания onAdd (Colyseus 0.16 + immediate:true
+        // может триггерить .onAdd на каждый schema patch). Локальный set хранит
+        // sessionId которые уже обработаны в ТЕКУЩЕМ sync объекте.
+        const _addedSessionIds = new Set();
         const handleAdd = (player, sessionId) => {
             // Не рисуем СЕБЯ как remote-меш — у нас уже есть PlayerController
             if (sessionId === this.room.sessionId) return;
+            // Защита от дублирующих onAdd событий для уже добавленного игрока
+            if (_addedSessionIds.has(sessionId)) return;
+            _addedSessionIds.add(sessionId);
             this._addRemotePlayer(sessionId, player);
             // Подписываемся на изменения этого Player'а
             $(player).onChange(() => this._updateRemoteTarget(sessionId, player));
@@ -149,7 +156,11 @@ export class MultiplayerSync {
                 this._attachRemoteWeapon(sessionId, val || '');
             });
         };
+        // Используем тот же set в handleRemove чтобы при настоящем уходе игрока
+        // потом можно было его снова добавить.
+        this._addedSessionIds = _addedSessionIds;
         const handleRemove = (player, sessionId) => {
+            if (this._addedSessionIds) this._addedSessionIds.delete(sessionId);
             this._removeRemotePlayer(sessionId);
         };
 
@@ -289,8 +300,20 @@ export class MultiplayerSync {
 
             // Интерполяция remote-игроков (позиция + yaw ставится на root,
             // модель — child root'а — следует за ним).
+            // 2026-06-05: читаем target напрямую из room.state.players —
+            // в Colyseus 0.16 onChange может не срабатывать для всех полей
+            // (особенно yaw/animState), а target.x/y/z/yaw обновляется
+            // через _updateRemoteTarget только из onChange. Подстраховка.
             for (const rp of this.remotePlayers.values()) {
                 if (!rp.root || !rp.target) continue;
+                const livePlayer = this.room?.state?.players?.get?.(rp.sessionId);
+                if (livePlayer) {
+                    rp.target.x = livePlayer.x;
+                    rp.target.y = livePlayer.y;
+                    rp.target.z = livePlayer.z;
+                    rp.target.yaw = livePlayer.yaw || 0;
+                    if (livePlayer.animState) rp.animState = livePlayer.animState;
+                }
                 const cur = rp.current;
                 cur.x += (rp.target.x - cur.x) * LERP_FACTOR;
                 cur.y += (rp.target.y - cur.y) * LERP_FACTOR;
@@ -332,13 +355,25 @@ export class MultiplayerSync {
                 // Развилка: R15-скины анимируются процедурно через R15Animator
                 // (как локальный игрок), Kenney-модели — через glTF AnimationGroups.
                 if (rp.isR15 && rp.r15Animator && rp.modelLoaded) {
-                    // Серверный animState: 'idle' | 'run' | 'attack'. R15Animator
+                    // Серверный animState: 'idle' | 'run' | 'jump' | 'fall' | 'attack'.
-                    // понимает idle/walk/run/jump/fall. Сервер не различает
+                    // R15Animator понимает idle/walk/run/jump/fall.
-                    // walk/run и не шлёт прыжки → маппим run→run, attack→idle
+                    // 2026-06-05: раньше run/jump/fall маппились в idle (баг
-                    // (атака показывается отдельным swing-ом руки ниже).
+                    // в маппинге), из-за чего у remote-игроков не было
-                    const r15State = rp.isDead
+                    // анимации ни ходьбы, ни прыжка. Теперь пробрасываем
-                        ? 'idle'
+                    // напрямую. attack показывается отдельным swing руки.
-                        : (rp.animState === 'run' ? 'run' : 'idle');
+                    let r15State;
+                    if (rp.isDead) {
+                        r15State = 'idle';
+                    } else if (rp.animState === 'jump') {
+                        r15State = 'jump';
+                    } else if (rp.animState === 'fall') {
+                        r15State = 'fall';
+                    } else if (rp.animState === 'run') {
+                        r15State = 'run';
+                    } else {
+                        // 'attack' или 'idle' или неизвестное — стоим
+                        r15State = 'idle';
+                    }
                     rp.r15Animator.setState(r15State);
                     rp.r15Animator.update(dt);
                 } else if (!rp.isR15) {
@@ -632,6 +667,23 @@ export class MultiplayerSync {
     // === Внутреннее: меши remote-игроков ===
     // =================================================================
     _addRemotePlayer(sessionId, player) {
+        // Защита от дублей при Colyseus reconnect: state получается заново
+        // и onAdd срабатывает для тех же sessionId. Без этой проверки в
+        // сцене появляются клоны игроков (см. issue после 2026-06-05).
+        if (this.remotePlayers && this.remotePlayers.has(sessionId)) {
+            const existing = this.remotePlayers.get(sessionId);
+            // Обновим target позицию и пометим что игрок жив
+            const sx2 = player.x || 0, sy2 = player.y || 0, sz2 = player.z || 0, yaw2 = player.yaw || 0;
+            existing.target = { x: sx2, y: sy2, z: sz2, yaw: yaw2 };
+            existing.username = player.username || sessionId;
+            existing.modelType = player.modelType || existing.modelType;
+            existing.hp = player.hp ?? existing.hp;
+            existing.maxHp = player.maxHp ?? existing.maxHp;
+            existing.isDead = !!player.isDead;
+            existing.animState = player.animState || existing.animState;
+            console.log(`[MultiplayerSync] re-add (reconnect): ${sessionId} (${player.username}) — обновили без пересоздания меша`);
+            return;
+        }
         const sx = player.x || 0;
         const sy = player.y || 0;
         const sz = player.z || 0;

src/engine/PrimitiveManager.js

@@ -485,12 +485,40 @@ export class PrimitiveManager {
                 break;
             case 'glass':
                 mat.alpha = 0.4;
-                mat.specularColor = new Color3(0.5, 0.5, 0.5);
+                mat.specularColor = new Color3(0.8, 0.85, 0.9);
+                mat.specularPower = 96;
+                mat.backFaceCulling = false;
                 break;
             case 'neon':
                 mat.emissiveColor = Color3.FromHexString(color || '#888888');
                 mat.specularColor = new Color3(0, 0, 0);
                 break;
+            case 'chrome': {
+                const cc = Color3.FromHexString(color || '#cfd6e0');
+                mat.diffuseColor = new Color3(cc.r * 0.6, cc.g * 0.6, cc.b * 0.6);
+                mat.specularColor = new Color3(1, 1, 1);
+                mat.specularPower = 128;
+                mat.emissiveColor = new Color3(cc.r * 0.12, cc.g * 0.12, cc.b * 0.14);
+                break;
+            }
+            case 'water': {
+                const wc = Color3.FromHexString(color || '#3aa0ff');
+                mat.diffuseColor = wc;
+                mat.alpha = 0.55;
+                mat.specularColor = new Color3(0.9, 0.95, 1.0);
+                mat.specularPower = 64;
+                mat.emissiveColor = new Color3(wc.r * 0.1, wc.g * 0.14, wc.b * 0.2);
+                mesh._isWater = true;
+                break;
+            }
+            case 'iridescent': {
+                const ic = Color3.FromHexString(color || '#a06bff');
+                mat.diffuseColor = ic;
+                mat.emissiveColor = new Color3(ic.r * 0.5, ic.g * 0.35, ic.b * 0.6);
+                mat.specularColor = new Color3(1, 1, 1);
+                mat.specularPower = 96;
+                break;
+            }
             case 'studs': {
                 // Лего-материал (паритет со студией): почти-белая diffuse × цвет
                 // меша + normal map. emissive = доля цвета → сочность (Roblox-look).

src/engine/RbxlHudOverlay.js

@@ -0,0 +1,177 @@
+/**
+ * RbxlHudOverlay — DOM-оверлей с HUD-элементами для импортированных
+ * Roblox-карт: KillFeed (правый верх), Message/Hint (центр), WinGui.
+ *
+ * Один контейнер `.rbxl-hud-overlay` на canvas.parentElement, в нём дочерние
+ * блоки по типу. Стили inline, ничего не зависит от CSS приложения.
+ *
+ * API:
+ *   const hud = new RbxlHudOverlay(canvasParent);
+ *   hud.addKillFeed(killer, victim, weapon)
+ *   hud.showMessage(text, opts)
+ *   hud.hideMessage()
+ *   hud.showWin(text)
+ *   hud.dispose()
+ */
+
+export class RbxlHudOverlay {
+    constructor(parent) {
+        this._parent = parent || document.body;
+        this._root = null;
+        this._killFeed = null;
+        this._message = null;
+        this._winBox = null;
+        this._killEntries = [];      // [{el, expireAt}]
+        this._mount();
+    }
+
+    _mount() {
+        if (this._root) return;
+        const root = document.createElement('div');
+        root.className = 'rbxl-hud-overlay';
+        Object.assign(root.style, {
+            position: 'absolute',
+            inset: '0',
+            pointerEvents: 'none',
+            zIndex: '999',
+            fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif',
+        });
+        this._parent.appendChild(root);
+        this._root = root;
+
+        // KillFeed — правый верхний угол
+        const kf = document.createElement('div');
+        Object.assign(kf.style, {
+            position: 'absolute',
+            top: '60px',
+            right: '12px',
+            display: 'flex',
+            flexDirection: 'column',
+            gap: '6px',
+            maxWidth: '320px',
+            pointerEvents: 'none',
+        });
+        root.appendChild(kf);
+        this._killFeed = kf;
+
+        // Message — центр сверху (Roblox Message по центру экрана,
+        // но в верхней трети чтобы не мешать игре)
+        const msg = document.createElement('div');
+        Object.assign(msg.style, {
+            position: 'absolute',
+            top: '15%',
+            left: '50%',
+            transform: 'translateX(-50%)',
+            padding: '10px 24px',
+            background: 'rgba(0,0,0,0.6)',
+            color: '#fff',
+            fontSize: '22px',
+            fontWeight: '600',
+            borderRadius: '6px',
+            textShadow: '0 2px 4px rgba(0,0,0,0.8)',
+            display: 'none',
+            pointerEvents: 'none',
+        });
+        root.appendChild(msg);
+        this._message = msg;
+
+        // WinGui — большая надпись по центру
+        const win = document.createElement('div');
+        Object.assign(win.style, {
+            position: 'absolute',
+            top: '50%',
+            left: '50%',
+            transform: 'translate(-50%, -50%)',
+            padding: '24px 48px',
+            background: 'rgba(0,0,0,0.75)',
+            color: '#ffd86b',
+            fontSize: '48px',
+            fontWeight: '800',
+            borderRadius: '12px',
+            textShadow: '0 4px 8px rgba(0,0,0,0.8)',
+            display: 'none',
+            pointerEvents: 'none',
+        });
+        root.appendChild(win);
+        this._winBox = win;
+
+        // Тик для авто-исчезновения KillFeed entries (через 5с)
+        this._tickInterval = setInterval(() => this._cleanupKills(), 500);
+    }
+
+    addKillFeed(killer, victim, weapon) {
+        if (!this._killFeed) return;
+        const entry = document.createElement('div');
+        Object.assign(entry.style, {
+            background: 'rgba(0,0,0,0.55)',
+            color: '#fff',
+            padding: '6px 10px',
+            borderRadius: '4px',
+            fontSize: '13px',
+            display: 'flex',
+            gap: '6px',
+            alignItems: 'center',
+            animation: 'rbxlHudFadeIn 0.3s',
+        });
+        const killerEl = document.createElement('span');
+        killerEl.textContent = String(killer || '?');
+        killerEl.style.color = '#5bd1e8';
+        const arrow = document.createElement('span');
+        arrow.textContent = weapon ? `→ [${weapon}] →` : '→';
+        arrow.style.color = '#ff9a52';
+        const victimEl = document.createElement('span');
+        victimEl.textContent = String(victim || '?');
+        victimEl.style.color = '#f87a7a';
+        entry.appendChild(killerEl);
+        entry.appendChild(arrow);
+        entry.appendChild(victimEl);
+        this._killFeed.appendChild(entry);
+        this._killEntries.push({ el: entry, expireAt: performance.now() + 5000 });
+        // Keep only last 8
+        while (this._killEntries.length > 8) {
+            const old = this._killEntries.shift();
+            try { old.el.remove(); } catch (_) {}
+        }
+    }
+
+    _cleanupKills() {
+        const now = performance.now();
+        const keep = [];
+        for (const e of this._killEntries) {
+            if (e.expireAt < now) { try { e.el.remove(); } catch (_) {} }
+            else keep.push(e);
+        }
+        this._killEntries = keep;
+    }
+
+    showMessage(text, opts = {}) {
+        if (!this._message) return;
+        this._message.textContent = String(text || '');
+        this._message.style.display = text ? 'block' : 'none';
+        if (opts.duration) {
+            clearTimeout(this._msgTimer);
+            this._msgTimer = setTimeout(() => this.hideMessage(), opts.duration);
+        }
+    }
+
+    hideMessage() {
+        if (this._message) this._message.style.display = 'none';
+    }
+
+    showWin(text) {
+        if (!this._winBox) return;
+        this._winBox.textContent = String(text || '');
+        this._winBox.style.display = 'block';
+        // Auto-hide через 6с
+        clearTimeout(this._winTimer);
+        this._winTimer = setTimeout(() => { if (this._winBox) this._winBox.style.display = 'none'; }, 6000);
+    }
+
+    dispose() {
+        try { this._root?.remove(); } catch (_) {}
+        clearInterval(this._tickInterval);
+        clearTimeout(this._msgTimer);
+        clearTimeout(this._winTimer);
+        this._root = null;
+    }
+}

src/engine/ScriptSandboxWorker.js

@@ -70,6 +70,8 @@ let _placeOnPlaceHandlers = [];
 let _placeOnCancelHandlers = [];
 let _placeOnMoveHandlers = [];
 let _invUiSlotClickHandlers = [];
+// Задача 05: зеркало видимости экрана загрузки (для game.loading.isVisible()).
+let _loadingVisible = false;
 // Мультиплеер (Фаза 4.3): снимок игроков комнаты { me, list }.
 let _players = { me: null, list: [] };
 // Общее состояние комнаты game.room.get/set — зеркало из main thread.
@@ -121,6 +123,13 @@ let _unlockedSkins = [];
 let _currentSkin = null;
 let _skinChangeHandlers = [];
 let _skinCoins = 0;   // локальная валюта магазина скинов (рублики проекта)
+// Phase 6.4 / задача 20: custom tools, leaderstats, achievements, remote events
+let _toolSeq = 0;
+let _toolCallbacks = {};      // toolId → { activated, equipped, unequipped }
+let _lsMirror = {};           // playerId('@me'|sid) → { statName: value }
+let _lsChangeHandlers = [];
+let _achUnlocked = {};        // id → true
+let _remoteHandlers = {};     // remoteName → [fn]
 // Подписки game.gui.onClick(id, fn)
 let _guiClickHandlers = {};
 // Подписки game.gui.onSubmit(id, fn) — ввод в TextBox завершён (Enter)
@@ -682,7 +691,9 @@ function _buildSelfApi() {
                 _send('self.move', { target: _target, x: nx, y: ny, z: nz });
             }
         },
-        /** Повернуть объект-носитель вокруг оси Y на угол ry (радианы). */
+        /**
+         * Повернуть объект-носитель вокруг вертикальной оси Y на угол ry (радианы).
+         */
         rotate(ry) {
             const r = Number(ry);
             if (!Number.isFinite(r)) return;
@@ -697,7 +708,7 @@ function _buildSelfApi() {
             const id = _target.id ?? _target.ref;
             _send('scene.setVisible', { kind: k, id, ref: (k && id != null) ? (k + ':' + id) : undefined, visible: !!vis });
         },
-        /** Включить/выключить столкновения объекта-носителя. */
+        /** Включить/выключить столкновения объекта-носителя (проходимость). */
         setCollide(can) {
             const k = _target.kind;
             const id = _target.id ?? _target.ref;
@@ -710,13 +721,14 @@ function _buildSelfApi() {
             const id = _target.id ?? _target.ref;
             _send('scene.setColor', { kind: k, id, ref: (k && id != null) ? (k + ':' + id) : undefined, color: hex });
         },
-        /** Повесить текст-метку над объектом-носителем. */
+        /** Повесить текст-метку над объектом-носителем (имя/HP). */
         setLabel(text, opts) {
             const k = _target.kind;
             const id = _target.id ?? _target.ref;
             const ref = (k && id != null) ? (k + ':' + id) : undefined;
             _send('scene.setLabel', { ref, text: String(text == null ? '' : text), opts: opts || {} });
         },
+        /** Убрать метку с объекта-носителя. */
         clearLabel() {
             const k = _target.kind;
             const id = _target.id ?? _target.ref;
@@ -1155,6 +1167,18 @@ const game = {
          *   game.player.giveTool('blaster-blaster-a', { equip: true });
          */
         giveTool(toolType, opts) {
+            // Phase 6.4: принимаем и Tool-объект (из game.tools.create), и строку.
+            if (toolType && typeof toolType === 'object' && toolType.id) {
+                _send('inventory.give', {
+                    kind: toolType.kind || 'tool',
+                    modelTypeId: toolType.modelTypeId || null,
+                    name: toolType.name,
+                    customToolId: toolType.id,
+                    params: {},
+                    equip: opts?.equip === true,
+                });
+                return;
+            }
             if (typeof toolType !== 'string' || !toolType) return;
             opts = opts || {};
             const isBlaster = toolType.indexOf('blaster') === 0;
@@ -1269,7 +1293,8 @@ const game = {
      *   game.tween(coin, { sy: 1.4 }, { duration: 0.5, yoyo: true, repeat: -1 });
      */
     tween(ref, props, opts) {
-        if (typeof ref !== 'string' || !props || typeof props !== 'object') return null;
+        ref = _normRef(ref);
+        if (!ref || !props || typeof props !== 'object') return null;
         opts = opts || {};
         const id = ++_tweenSeq;
         if (typeof opts.onDone === 'function') _tweenCallbacks[id] = opts.onDone;
@@ -1380,6 +1405,32 @@ const game = {
         if (!sessionId) return;
         _send('mp.sendTo', { sessionId, name, data });
     },
+
+    /**
+     * Phase 6.6: RemoteEvent — именованные сетевые события (как в Roblox).
+     *   const ev = game.remote.create('PlayerShoot');
+     *   ev.fireAllClients({ x: 10, y: 5 });
+     *   ev.on(({ from, data }) => { ... });
+     */
+    remote: {
+        create(name) {
+            const evName = String(name || '');
+            return {
+                get name() { return evName; },
+                fireAllClients(data) { _send('mp.remoteFire', { name: evName, target: 'all', data }); },
+                fireOthers(data) { _send('mp.remoteFire', { name: evName, target: 'others', data }); },
+                fireClient(player, data) {
+                    const sid = typeof player === 'string' ? player : (player && player.sessionId);
+                    if (!sid) return;
+                    _send('mp.remoteFire', { name: evName, target: sid, data });
+                },
+                on(fn) {
+                    if (typeof fn !== 'function') return;
+                    (_remoteHandlers[evName] = _remoteHandlers[evName] || []).push(fn);
+                },
+            };
+        },
+    },
     /**
      * Подписаться на изменение HP игрока (получение урона / лечение / смерть).
      * fn(event) где event = { hp, maxHp, source, damaged, delta }.
@@ -2727,6 +2778,7 @@ const game = {
         _localSeq: 0,
         _localToReal: new Map(),     // localId → реальный loadingId (приходит в loadingShown)
         _handlers: new Map(),        // localId → { onSkip:[], onComplete:[] }
+        _onHide: [],                 // задача 05 — глобальные подписки на скрытие
         show(opts) {
             opts = opts && typeof opts === 'object' ? opts : {};
             const localId = ++this._localSeq;
@@ -2745,11 +2797,20 @@ const game = {
                 setProgress(v) { _send('loading.setProgress', { localId, value: Number(v) || 0 }); },
                 setText(t) { _send('loading.setText', { localId, text: String(t == null ? '' : t) }); },
                 setCover(c) { _send('loading.setCover', { localId, cover: c }); },
+                setBackground(b) { _send('loading.setBackground', { localId, background: b }); },
                 close() { _send('loading.close', { localId }); },
                 onSkip(fn) { if (typeof fn === 'function') self._handlers.get(localId)?.onSkip.push(fn); },
                 onComplete(fn) { if (typeof fn === 'function') self._handlers.get(localId)?.onComplete.push(fn); },
             };
         },
+        // --- Задача 05: управление активным экраном без хэндла (стартовый/любой текущий) ---
+        onHide(fn) { if (typeof fn === 'function') this._onHide.push(fn); },
+        setBackground(b) { _send('loading.setBackground', { background: b }); },
+        setText(t) { _send('loading.setText', { text: String(t == null ? '' : t) }); },
+        setCover(c) { _send('loading.setCover', { cover: c }); },
+        setProgress(v) { _send('loading.setProgress', { value: Number(v) || 0 }); },
+        hide() { _send('loading.close', {}); },
+        isVisible() { return !!_loadingVisible; },
         /** Типовой переход с фейковым прогрессом. Возвращает Promise (резолв по complete/skip). */
         transition(opts) {
             opts = opts && typeof opts === 'object' ? { ...opts } : {};
@@ -2807,7 +2868,7 @@ const game = {
         clear() {
             _send('inventory.clear', {});
         },
-        // === Задача 44: drag-drop инвентарь ===
+        // === Задача 44: drag-drop инвентарь (сетка 8×5 + hotbar 9 + стаки) ===
         give(itemId, count) { _send('inv2.add', { itemId, count: Number(count) || 1 }); },
         take(itemId, count) { _send('inv2.remove', { itemId, count: Number(count) || 1 }); },
         open() { _send('inv2.open', {}); },
@@ -2816,12 +2877,87 @@ const game = {
         sort(by) { _send('inv2.sort', { by: by || 'rarity' }); },
         setActiveHotbar(i) { _send('inv2.setActive', { i: Number(i) || 0 }); },
     },
+
+    // === Phase 6.4: пользовательские tools (как Roblox Tool) ===
+    tools: {
+        create(name, opts) {
+            opts = opts || {};
+            _toolSeq++;
+            const toolId = 'custom:' + _toolSeq;
+            _toolCallbacks[toolId] = {};
+            const tool = {
+                get id() { return toolId; },
+                get name() { return String(name || ('Tool ' + _toolSeq)); },
+                get modelTypeId() { return opts.model || null; },
+                get kind() { return opts.kind || 'tool'; },
+                onActivated(fn) { if (typeof fn === 'function') _toolCallbacks[toolId].activated = fn; },
+                onEquipped(fn) { if (typeof fn === 'function') _toolCallbacks[toolId].equipped = fn; },
+                onUnequipped(fn) { if (typeof fn === 'function') _toolCallbacks[toolId].unequipped = fn; },
+                dropAt(pos) {
+                    if (!pos || typeof pos !== 'object') return;
+                    _send('tools.drop', {
+                        toolId, name: String(name), model: opts.model || null,
+                        params: opts.params || {},
+                        x: Number(pos.x) || 0, y: Number(pos.y) || 0, z: Number(pos.z) || 0,
+                    });
+                },
+            };
+            return tool;
+        },
+    },
+
+    // === Определения предметов (задача 44) ===
     items: {
         define(def) {
             if (Array.isArray(def)) { for (const d of def) _send('items.define', { def: d }); return; }
             _send('items.define', { def: def || {} });
         },
     },
+
+    // === Лидерборды (leaderstats) — задача 20 ===
+    leaderstats: {
+        define(name, opts) {
+            if (typeof name !== 'string' || !name) return;
+            _send('leaderstats.define', { name, opts: opts || {} });
+        },
+        set(playerId, name, value) {
+            _send('leaderstats.set', { playerId: playerId == null ? null : String(playerId), name, value: Number(value) || 0 });
+            const pid = playerId == null ? '@me' : String(playerId);
+            if (!_lsMirror[pid]) _lsMirror[pid] = {};
+            _lsMirror[pid][name] = Number(value) || 0;
+        },
+        add(playerId, name, delta) {
+            _send('leaderstats.add', { playerId: playerId == null ? null : String(playerId), name, delta: Number(delta) || 0 });
+            const pid = playerId == null ? '@me' : String(playerId);
+            if (!_lsMirror[pid]) _lsMirror[pid] = {};
+            _lsMirror[pid][name] = (_lsMirror[pid][name] || 0) + (Number(delta) || 0);
+        },
+        get(playerId, name) {
+            const pid = playerId == null ? '@me' : String(playerId);
+            return (_lsMirror[pid] && _lsMirror[pid][name]) || 0;
+        },
+        onChange(fn) { if (typeof fn === 'function') _lsChangeHandlers.push(fn); },
+        me: {
+            set(name, value) { game.leaderstats.set(null, name, value); },
+            add(name, delta) { game.leaderstats.add(null, name, delta); },
+            get(name) { return game.leaderstats.get(null, name); },
+        },
+    },
+
+    // === Достижения — задача 20 ===
+    achievements: {
+        define(list) { _send('achievements.define', { list: Array.isArray(list) ? list : [list] }); },
+        unlock(id, playerId) {
+            if (typeof id !== 'string') return;
+            _achUnlocked[id] = true;
+            _send('achievements.unlock', { id, playerId: playerId == null ? null : String(playerId) });
+        },
+        has(id) { return !!_achUnlocked[id]; },
+        bindToStat(id, statName, cond) { _send('achievements.bindToStat', { id, statName, cond: cond || {} }); },
+        setButtonVisible(v) { _send('achievements.setButtonVisible', { visible: !!v }); },
+        openPage() { _send('achievements.openPage', {}); },
+    },
+
     /**
      * Игроки комнаты (Фаза 4.3 — мультиплеер).
      * В одиночной игре (редактор) — только локальный игрок.
@@ -3365,6 +3501,41 @@ const game = {
             _send('environment.setTimeOfDay', { hours: h });
         },
     },
+    /**
+     * graphics — визуальные эффекты («шейдеры»): постобработка, свечение,
+     * цветокоррекция, тени. По умолчанию всё выключено.
+     */
+    graphics: {
+        setPreset(preset) {
+            if (typeof preset !== 'string') return;
+            _send('graphics.set', { preset });
+        },
+        set(settings) {
+            if (typeof settings !== 'object' || !settings) return;
+            _send('graphics.set', settings);
+        },
+        setBloom(on, opts) {
+            _send('graphics.set', { bloom: { enabled: !!on, ...(opts || {}) } });
+        },
+        setVignette(weight) {
+            const w = Number(weight) || 0;
+            _send('graphics.set', { vignette: { enabled: w > 0, weight: w } });
+        },
+        setColorGrading(opts) {
+            if (typeof opts !== 'object' || !opts) return;
+            _send('graphics.set', { grading: { enabled: true, ...opts } });
+        },
+        setAntialiasing(on) { _send('graphics.set', { fxaa: !!on }); },
+        setDepthOfField(on, opts) {
+            _send('graphics.set', { dof: { enabled: !!on, ...(opts || {}) } });
+        },
+        setShadows(quality) {
+            if (typeof quality !== 'string') return;
+            _send('graphics.set', { shadows: quality });
+        },
+        setSSAO(on) { _send('graphics.set', { ssao: !!on }); },
+        off() { _send('graphics.set', { preset: 'off' }); },
+    },
     /**
      * Управление режимами ввода — курсор и камера.
      * В режиме 'ui' мышь работает как обычный курсор (как в браузере),
@@ -3935,12 +4106,15 @@ self.onmessage = (e) => {
         if (t === 'click') {
             for (const fn of _globalClickHandlers) _safeCall(fn, payload, 'onClick');
         } else if (t === 'leaderstatsChange') {
-            // Задача 20: стат изменился на main — обновляем зеркало + onChange.
+            // Задача 20: стат изменился на сервере/main — обновляем зеркало + onChange.
             const pid = payload.playerId == null ? '@me' : String(payload.playerId);
             if (!_lsMirror[pid]) _lsMirror[pid] = {};
             _lsMirror[pid][payload.name] = payload.newValue;
             if (payload.isMe) { if (!_lsMirror['@me']) _lsMirror['@me'] = {}; _lsMirror['@me'][payload.name] = payload.newValue; }
-            for (const fn of _lsChangeHandlers) { try { fn(payload.playerId, payload.name, payload.newValue, payload.oldValue); } catch (err) { _send('log', { level: 'error', text: 'leaderstats.onChange: ' + (err && err.message ? err.message : err) }); } }
+            for (const fn of _lsChangeHandlers) {
+                try { fn(payload.playerId, payload.name, payload.newValue, payload.oldValue); }
+                catch (err) { _send('log', { level: 'error', text: 'leaderstats.onChange: ' + (err && err.message ? err.message : err) }); }
+            }
         } else if (t === 'achievementUnlocked') {
             _achUnlocked[payload.id] = true;
         } else if (t === 'mouseMove') {
@@ -3997,13 +4171,34 @@ self.onmessage = (e) => {
                 for (const fn of arr) _safeCall(fn, ev, 'npc.onDeath');
             }
         } else if (t === 'toolUse') {
-            // payload: { tool: {kind, modelTypeId, name}, point, target }
+            // payload: { tool: {kind, modelTypeId, name, customToolId?}, point, target }
             const ev = {
                 tool: payload.tool || null,
                 point: payload.point || null,
                 target: payload.target || null,
             };
+            // Phase 6.4: per-tool callback из game.tools.create -> onActivated.
+            const customId = payload.tool && payload.tool.customToolId;
+            if (customId && _toolCallbacks[customId] && _toolCallbacks[customId].activated) {
+                _safeCall(_toolCallbacks[customId].activated, ev, 'tool.onActivated:' + customId);
+            }
             for (const fn of _toolUseHandlers) _safeCall(fn, ev, 'onToolUse');
+        } else if (t === 'toolEquipped') {
+            const customId = payload && payload.tool && payload.tool.customToolId;
+            if (customId && _toolCallbacks[customId] && _toolCallbacks[customId].equipped) {
+                _safeCall(_toolCallbacks[customId].equipped, payload, 'tool.onEquipped:' + customId);
+            }
+        } else if (t === 'toolUnequipped') {
+            const customId = payload && payload.tool && payload.tool.customToolId;
+            if (customId && _toolCallbacks[customId] && _toolCallbacks[customId].unequipped) {
+                _safeCall(_toolCallbacks[customId].unequipped, payload, 'tool.onUnequipped:' + customId);
+            }
+        } else if (t === 'remoteEvent') {
+            // Phase 6.6: RemoteEvent от сервера. payload: { from, name, data }
+            const arr = _remoteHandlers[payload.name] || [];
+            for (const fn of arr) {
+                _safeCall(fn, { from: payload.from, data: payload.data }, 'remote.on:' + payload.name);
+            }
         } else if (t === 'cutsceneDone') {
             // Катсцена камеры завершилась (Фаза 5.7).
             for (const fn of _cutsceneDoneHandlers) _safeCall(fn, undefined, 'onCutsceneDone');
@@ -4122,6 +4317,7 @@ self.onmessage = (e) => {
             } catch (e) {}
         } else if (t === 'loadingShown') {
             // Задача 12: реальный loadingId от runtime — маппим local→real.
+            _loadingVisible = true;
             try {
                 const lo = (typeof game !== 'undefined') && game.loading;
                 if (lo && payload && payload.replyId) {
@@ -4131,6 +4327,13 @@ self.onmessage = (e) => {
                     }
                 }
             } catch (e) {}
+        } else if (t === 'loadingHidden') {
+            // Задача 05: экран скрылся — зеркало + onHide-подписки.
+            _loadingVisible = false;
+            try {
+                const lo = (typeof game !== 'undefined') && game.loading;
+                if (lo) for (const fn of (lo._onHide || [])) _safeCall(fn, undefined, 'loading.onHide');
+            } catch (e) {}
         } else if (t === 'loadingSkip' || t === 'loadingComplete') {
             // Игрок нажал «Пропустить» или прогресс достиг 100% — зовём подписчиков.
             try {

src/engine/lua/LuaSharedSandbox.js

@@ -0,0 +1,337 @@
+/**
+ * LuaSharedSandbox (v3, main-thread) — wasmoon-VM работает в MAIN потоке,
+ * без Web Worker. Это позволяет:
+ *   - Видеть точные Lua-ошибки в DevTools (через console.error)
+ *   - Использовать debugger / breakpoints прямо в RobloxShim.js
+ *   - Не возиться с молчаливыми Worker-падениями
+ *
+ * Цена: тяжёлые Lua-скрипты могут блокировать UI. Для KillBrick-style
+ * скриптов это нестрашно — они быстрые.
+ *
+ * API совместим с ScriptSandbox: setOnCommand / sendEvent / sendGlobalEvent /
+ * sendSceneSnapshot / sendGuiSnapshot / sendDataSnapshot / sendSkinsSnapshot /
+ * sendTerrainHeightmap / stop / tick / target.
+ *
+ * Что добавлено сверх ScriptSandbox:
+ *   - addScript(id, code, target) — добавить скрипт в общий VM. Можно
+ *     до или после start().
+ *   - start() — асинхронен (createEngine), но возвращает сразу. После init
+ *     стартует main loop (Heartbeat + scheduler).
+ */
+
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxShim } from './RobloxShim.js';
+
+export class LuaSharedSandbox {
+    constructor() {
+        this.vm = null;
+        this.api = null;
+        this._onCommand = null;
+        this._isReady = false;
+        this._isStopped = false;
+        this._isKickedOff = false;
+        this._pendingScripts = [];   // [{id, code, target, name}]
+        this._scriptsById = new Map();
+        this._scenes = null;
+        this._guiTree = null;
+        this._loopHandle = null;
+        this._lastTickAt = 0;
+        // Маркер для GameRuntime.routeEvent — этот sandbox принимает все
+        // события и сам маршрутизирует через shim.fireTargetEvent.
+        this._luaShared = true;
+    }
+
+    setOnCommand(cb) { this._onCommand = cb; }
+
+    get target() { return null; }
+    tick(_dt, _state) { /* no-op: main-loop запускается изнутри (setInterval) */ }
+
+    addScript(id, code, target, name, extra) {
+        const entry = {
+            id: String(id || `lua_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`),
+            code: String(code || ''),
+            target: target == null ? null : target,
+            name: name || null,
+            toolName: extra?.toolName || null,
+        };
+        this._scriptsById.set(entry.id, entry);
+        if (!this._isKickedOff) {
+            this._pendingScripts.push(entry);
+        } else {
+            this._startSingleScript(entry);
+        }
+    }
+
+    removeScript(id) {
+        this._scriptsById.delete(String(id));
+    }
+
+    /** Стартует VM, регистрирует shim, запускает main-loop. */
+    start() {
+        if (this.vm || this._isStopped) return;
+        // eslint-disable-next-line no-console
+        console.log('[LuaSharedSandbox v3] starting Lua VM in main thread...');
+        this._initAsync().catch((err) => {
+            // eslint-disable-next-line no-console
+            console.error('[LuaSharedSandbox] FATAL init error:', err);
+            this._emit('log', { level: 'error', text: `Lua-runtime init: ${err?.message || err}` });
+        });
+    }
+
+    async _initAsync() {
+        const factory = new LuaFactory();
+        this.vm = await factory.createEngine({ openStandardLibs: true });
+        // eslint-disable-next-line no-console
+        console.log('[LuaSharedSandbox] VM created. Registering Roblox shim...');
+
+        // Адаптер для shim'а: он ожидает send(cmd, payload), getSceneSnapshot, getGuiTree, scheduleWait.
+        const send = (cmd, payload) => this._emit(cmd, payload);
+
+        this.api = registerRobloxShim(this.vm, {
+            send,
+            getSceneSnapshot: () => this._scenes,
+            getGuiTree: () => this._guiTree,
+            scheduleWait: () => null,
+        });
+
+        // eslint-disable-next-line no-console
+        console.log('[LuaSharedSandbox] Shim registered. api keys:', Object.keys(this.api || {}));
+
+        // Применим snapshot если он есть
+        if (this._scenes && this.api?.onSceneSnapshot) {
+            try { this.api.onSceneSnapshot(this._scenes); } catch (e) {
+                console.error('[LuaSharedSandbox] onSceneSnapshot:', e);
+            }
+        }
+
+        this._isReady = true;
+        this._kickoff();
+    }
+
+    _kickoff() {
+        if (this._isKickedOff || this._isStopped) return;
+        this._isKickedOff = true;
+        // eslint-disable-next-line no-console
+        console.log(`[LuaSharedSandbox] kickoff: starting ${this._pendingScripts.length} scripts`);
+        const pending = this._pendingScripts;
+        this._pendingScripts = [];
+        // Запускаем main-loop сразу — он начнёт tick'ать как только будут coroutines.
+        this._lastTickAt = performance.now();
+        this._startMainLoop();
+        // Init батчами по 5 с задержкой 20мс между ними, чтобы UI отзывался.
+        const BATCH_SIZE = 5;
+        let idx = 0;
+        const initBatch = () => {
+            if (this._isStopped) return;
+            const end = Math.min(idx + BATCH_SIZE, pending.length);
+            for (let i = idx; i < end; i++) {
+                try { this._startSingleScript(pending[i]); }
+                catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('[LuaSharedSandbox] init batch err:', e);
+                }
+            }
+            idx = end;
+            if (idx < pending.length) {
+                setTimeout(initBatch, 20);
+            } else {
+                // eslint-disable-next-line no-console
+                console.log(`[LuaSharedSandbox] all ${pending.length} scripts kicked off`);
+                // После того как все скрипты подключили хендлеры — фейрим
+                // events для уже существующих сущностей. Roblox-конвенция:
+                // если игрок уже на сервере когда скрипт подключается,
+                // Players.PlayerAdded не сработает повторно. Юзеру нужно
+                // делать ручной обход GetPlayers() — но это редко кто помнит.
+                // Мы дублируем событие через короткую задержку.
+                setTimeout(() => {
+                    try {
+                        if (this.api?.fireExistingPlayers) {
+                            this.api.fireExistingPlayers();
+                        }
+                    } catch (e) {
+                        console.warn('[LuaSharedSandbox] fireExistingPlayers failed:', e);
+                    }
+                }, 100);
+            }
+        };
+        setTimeout(initBatch, 0);
+    }
+
+    _startSingleScript(entry) {
+        if (!this.vm || !entry || typeof entry.code !== 'string') return;
+        let primId = null;
+        if (typeof entry.target === 'number') primId = entry.target;
+        else if (entry.target && typeof entry.target === 'object') {
+            if (entry.target.kind === 'primitive') primId = entry.target.id ?? entry.target.ref;
+        }
+        const safeId = entry.id.replace(/[^a-zA-Z0-9_]/g, '_');
+        const scriptName = entry.name || `Script_${safeId}`;
+        // Скрипт оборачиваем в coroutine — это позволяет task.wait через yield.
+        // Резюмим coroutine из main-loop когда наступило время.
+        // Регистрируем coroutine в __rbxl_coroutines с id для возобновления.
+        // Скрипт оборачиваем в coroutine. task.wait()→coroutine.yield(sec) возвращает
+        // delay из resume → планируем следующий resume через scheduleResume.
+        // Fallback Parent: если скрипт связан с Tool (по имени Tool из metadata) —
+        // подсовываем виртуальный Tool как script.Parent. Иначе primitive по id,
+        // иначе workspace.
+        let parentExpr;
+        if (entry.toolName) {
+            // Tool создаётся в shim как Instance.new('Tool'). По имени достаём.
+            // Если не нашли — fallback на новый Tool того же имени.
+            const safeName = JSON.stringify(entry.toolName);
+            parentExpr = `(function()
+                local existing = __rbxl_get_tool_by_name(${safeName})
+                if existing then return existing end
+                local t = Instance.new("Tool")
+                t.Name = ${safeName}
+                return t
+            end)()`;
+        } else if (primId != null) {
+            parentExpr = `(__rbxl_get_part_by_id(${Number(primId)}) or workspace)`;
+        } else {
+            parentExpr = 'workspace';
+        }
+        const wrapped = `
+            do
+                -- Если parentExpr вернул primitive — у него уже есть :FindFirstChild и пр.
+                -- Если ничего не вернёт — workspace (всегда валидный).
+                -- script.Parent.Parent (Tool.Parent = StarterPack / Backpack / workspace).
+                local _scriptParent = ${parentExpr}
+                if _scriptParent == nil then _scriptParent = workspace end
+                if _scriptParent.Parent == nil then _scriptParent.Parent = workspace end
+                local script = setmetatable({
+                    Name = ${JSON.stringify(scriptName)},
+                    Parent = _scriptParent,
+                    ClassName = "Script",
+                    Disabled = false,
+                    Source = nil,
+                }, {
+                    -- Любой доступ к несуществующему полю → workspace
+                    -- (на случай script.Foo:Bar() в старом коде)
+                    __index = function(t, k)
+                        if k == "FindFirstChild" or k == "WaitForChild" or k == "GetChildren" then
+                            return function() return nil end
+                        end
+                        return workspace[k]
+                    end,
+                })
+                local co = coroutine.create(function()
+                    -- WATCHDOG: каждые 100000 инструкций — yield 1 кадр.
+                    -- НЕ оборачиваем в pcall — внутри C-call boundary yield
+                    -- упадёт ошибкой, что прервёт скрипт. Это лучше чем виснуть.
+                    debug.sethook(function()
+                        coroutine.yield(0.016)
+                    end, "", 20000)
+                    -- pcall защищает от runtime-ошибок которые иначе крашат
+                    -- coroutine и могут повредить WASM-стейт. Возвраты
+                    -- handler'а намеренно поглощаются.
+                    local ok_, err_ = pcall(function()
+                        ${entry.code}
+                    end)
+                    if not ok_ then
+                        __rbxl_send_error(${JSON.stringify(entry.id)}, tostring(err_))
+                    end
+                end)
+                __rbxl_register_coroutine(${JSON.stringify(entry.id)}, co)
+                local ok, ret = coroutine.resume(co)
+                if not ok then
+                    __rbxl_send_error(${JSON.stringify(entry.id)}, tostring(ret))
+                    __rbxl_unregister_coroutine(${JSON.stringify(entry.id)})
+                elseif type(ret) == 'number' then
+                    -- скрипт yield'нул с delay (через task.wait) — планируем resume
+                    __rbxl_schedule_resume(${JSON.stringify(entry.id)}, ret)
+                elseif coroutine.status(co) == 'dead' then
+                    __rbxl_unregister_coroutine(${JSON.stringify(entry.id)})
+                end
+            end
+        `;
+        try {
+            this.vm.doStringSync(wrapped);
+            // eslint-disable-next-line no-console
+            console.log(`[LuaSharedSandbox] script ${entry.id} initialized OK`);
+        } catch (err) {
+            // eslint-disable-next-line no-console
+            console.error(`[LuaSharedSandbox] script ${entry.id} init FAILED:`, err);
+            this._emit('log', { level: 'error', text: `[Lua ${entry.id}] ${err?.message || err}` });
+        }
+    }
+
+    _startMainLoop() {
+        const tick = () => {
+            if (this._isStopped) return;
+            try {
+                const now = performance.now();
+                const dt = Math.min(0.1, (now - this._lastTickAt) / 1000);
+                this._lastTickAt = now;
+                if (this.api?.tickScheduler) this.api.tickScheduler(dt);
+                if (this.api?.fireHeartbeat) this.api.fireHeartbeat(dt);
+            } catch (e) {
+                // eslint-disable-next-line no-console
+                console.error('[LuaSharedSandbox tick]', e);
+            }
+            this._loopHandle = setTimeout(tick, 16);
+        };
+        this._loopHandle = setTimeout(tick, 16);
+    }
+
+    _emit(cmd, payload) {
+        if (typeof this._onCommand === 'function') {
+            try { this._onCommand({ cmd, payload }); } catch (_) {}
+        }
+    }
+
+    // ----- API совместимый с ScriptSandbox -----
+    sendEvent(payload) {
+        if (!this.api?.fireTargetEvent || !this._isReady) return;
+        try { this.api.fireTargetEvent(payload); } catch (e) {
+            console.error('[LuaSharedSandbox] sendEvent:', e);
+        }
+    }
+
+    sendGlobalEvent(payload) {
+        if (!this.api?.fireGlobalEvent || !this._isReady) return;
+        try { this.api.fireGlobalEvent(payload); } catch (e) {
+            console.error('[LuaSharedSandbox] sendGlobalEvent:', e);
+        }
+    }
+
+    sendSceneSnapshot(snapshot) {
+        this._scenes = snapshot;
+        if (this.api?.onSceneSnapshot && this._isReady) {
+            try { this.api.onSceneSnapshot(snapshot); } catch (e) {
+                console.error('[LuaSharedSandbox] onSceneSnapshot:', e);
+            }
+        }
+    }
+
+    sendGuiSnapshot(snapshot) {
+        this._guiTree = snapshot;
+        if (this.api?.onGuiSnapshot && this._isReady) {
+            try { this.api.onGuiSnapshot(snapshot); } catch (_) {}
+        }
+    }
+
+    sendDataSnapshot(snapshot) {
+        if (this.api?.onDataSnapshot && this._isReady) {
+            try { this.api.onDataSnapshot(snapshot); } catch (_) {}
+        }
+    }
+
+    sendSkinsSnapshot(_) { /* no-op для Этапа 3 */ }
+    sendTerrainHeightmap(_) { /* no-op */ }
+
+    stop() {
+        this._isStopped = true;
+        if (this._loopHandle) {
+            clearTimeout(this._loopHandle);
+            this._loopHandle = null;
+        }
+        if (this.vm) {
+            try { this.vm.global.close(); } catch (_) {}
+            this.vm = null;
+        }
+        this.api = null;
+    }
+}
+
+export default LuaSharedSandbox;

src/engine/rbxl-lua-integration.js

@@ -0,0 +1,210 @@
+/**
+ * rbxl-lua-integration.js — вспомогательные функции для импорта .rbxl-карт.
+ *
+ * Старый отдельный Worker-based runtime удалён (2026-06-08): импортированные
+ * Lua-скрипты теперь идут через тот же LuaSharedSandbox что и user-Lua
+ * (см. GameRuntime.start()). Этот файл оставлен только для:
+ *   - unpackRobloxLuaCode() — распаковка Lua из JS-комментария-обёртки;
+ *   - handleLuaCommand() — обработка partSet/sceneCreate/sceneDelete/playerCmd
+ *     команд от Lua-VM в BabylonScene.
+ */
+
+/** Распаковка lua_source из packed-кода. */
+export function unpackRobloxLuaCode(code) {
+    const openTag = '/[*] lua_source:\n'.replace('[*]', '*');
+    const i = code.indexOf(openTag);
+    if (i < 0) return null;
+    const start = i + openTag.length;
+    const closeIdx = code.lastIndexOf('\n*' + '/');
+    if (closeIdx < start) return null;
+    return code.slice(start, closeIdx);
+}
+
+/** Парсит JSON-метадату из 2-й строки packed-кода (`// {"roblox_class":..., "enabled": true}`). */
+export function parseRobloxLuaMeta(code) {
+    if (typeof code !== 'string') return null;
+    const lines = code.split('\n');
+    if (lines.length < 2) return null;
+    const metaLine = lines[1];
+    if (!metaLine.startsWith('// ')) return null;
+    try {
+        return JSON.parse(metaLine.slice(3));
+    } catch (_) {
+        return null;
+    }
+}
+
+/** Сцена → snap для shim'а (workspace:GetChildren). */
+export function buildLuaSceneSnap(primitives) {
+    const out = { primitives: {} };
+    if (!Array.isArray(primitives)) return out;
+    for (const p of primitives) {
+        out.primitives[p.id] = {
+            id: p.id, type: p.type, name: p.name,
+            x: p.x, y: p.y, z: p.z,
+            sx: p.sx, sy: p.sy, sz: p.sz,
+            color: p.color, material: p.material,
+            anchored: !!p.anchored, canCollide: p.canCollide !== false,
+            opacity: typeof p.opacity === 'number' ? p.opacity : 1,
+        };
+    }
+    return out;
+}
+
+/**
+ * GUI-tree для shim'а. Mapping origin → __roblox_class.
+ * scene.gui — массив элементов с {id, type, name, parentId, ...origin}.
+ * Возвращаем массив сохраняя порядок parent → child (важно для tree-сборки).
+ */
+export function buildLuaGuiTree(guiElements) {
+    if (!Array.isArray(guiElements)) return [];
+    const out = [];
+    for (const el of guiElements) {
+        // origin = 'roblox-textbutton' → 'TextButton'
+        let rblClass = 'Frame';
+        const origin = el.origin || '';
+        if (origin.startsWith('roblox-')) {
+            const tail = origin.slice(7);
+            rblClass = tail.charAt(0).toUpperCase() + tail.slice(1);
+            // Camel-case "textbutton" → "TextButton"
+            if (rblClass.toLowerCase() === 'textbutton') rblClass = 'TextButton';
+            else if (rblClass.toLowerCase() === 'textlabel') rblClass = 'TextLabel';
+            else if (rblClass.toLowerCase() === 'imagebutton') rblClass = 'ImageButton';
+            else if (rblClass.toLowerCase() === 'imagelabel') rblClass = 'ImageLabel';
+            else if (rblClass.toLowerCase() === 'textbox') rblClass = 'TextBox';
+            else if (rblClass.toLowerCase() === 'scrollingframe') rblClass = 'ScrollingFrame';
+            else if (rblClass.toLowerCase() === 'frame') rblClass = 'Frame';
+        } else {
+            // Если origin не задан — гадаем по type
+            const t = el.type;
+            if (t === 'button') rblClass = 'TextButton';
+            else if (t === 'text') rblClass = 'TextLabel';
+            else if (t === 'image') rblClass = 'ImageLabel';
+            else if (t === 'textbox') rblClass = 'TextBox';
+        }
+        out.push({
+            id: el.id,
+            name: el.name || rblClass,
+            parentId: el.parentId || null,
+            visible: el.visible !== false,
+            text: el.text || '',
+            __roblox_class: rblClass,
+        });
+    }
+    return out;
+}
+
+/**
+ * Обработка IPC команд от worker'а — мапим на действия в Babylon-сцене.
+ */
+export function handleLuaCommand(_scriptId, cmd, payload, runtime) {
+    if (cmd === 'log') {
+        const fn = payload?.level === 'error' ? console.error
+            : payload?.level === 'warn' ? console.warn : console.log;
+        fn('[rbxl-lua]', payload?.text || '');
+        return;
+    }
+    if (cmd === 'partSet') {
+        const pm = runtime.scene3d?.primitiveManager;
+        if (!pm) {
+            console.warn('[partSet] no primitiveManager. scene3d=', !!runtime.scene3d);
+            return;
+        }
+        const primId = payload?.primId;
+        const prop = payload?.prop;
+        const value = payload?.value;
+        const patch = {};
+        if (prop === 'position' && value) {
+            patch.x = value.x; patch.y = value.y; patch.z = value.z;
+        } else if (prop === 'cframe' && value) {
+            patch.x = value.x; patch.y = value.y; patch.z = value.z;
+            patch.rotationX = value.rx; patch.rotationY = value.ry; patch.rotationZ = value.rz;
+        } else if (prop === 'size' && value) {
+            patch.sx = value.sx; patch.sy = value.sy; patch.sz = value.sz;
+        } else if (prop === 'color') patch.color = value;
+        else if (prop === 'material') patch.material = value;
+        else if (prop === 'anchored') patch.anchored = value;
+        else if (prop === 'canCollide') patch.canCollide = value;
+        else if (prop === 'opacity') patch.opacity = value;
+        try {
+            if (typeof pm.updateInstance === 'function') pm.updateInstance(primId, patch);
+            else if (typeof pm.applyPatch === 'function') pm.applyPatch(primId, patch);
+            else if (typeof pm.update === 'function') pm.update(primId, patch);
+        } catch (e) {
+            console.error('[partSet] updateInstance failed:', e);
+        }
+        return;
+    }
+    if (cmd === 'sceneCreate') {
+        // Lua: Instance.new("Part") + part.Parent = workspace → создание примитива.
+        // payload: { primId (предложенный id), type, x, y, z, sx, sy, sz, color, anchored }
+        try {
+            const pm = runtime.scene3d?.primitiveManager;
+            if (!pm || typeof pm.addInstance !== 'function') return;
+            const opts = {
+                id: payload?.primId,
+                x: payload?.x || 0, y: payload?.y || 0, z: payload?.z || 0,
+                sx: payload?.sx || 1, sy: payload?.sy || 1, sz: payload?.sz || 1,
+                color: payload?.color,
+                anchored: payload?.anchored !== false,
+                canCollide: payload?.canCollide !== false,
+            };
+            pm.addInstance(payload?.type || 'cube', opts);
+            // Если unanchored — регистрируем в физике на лету, иначе он не падает.
+            if (opts.anchored === false) {
+                try {
+                    const dm = runtime.scene3d?.dynamics;
+                    const data = pm.instances?.get?.(opts.id);
+                    if (dm && data && typeof dm.registerPrimitive === 'function') {
+                        dm.registerPrimitive(data);
+                    }
+                } catch (e) {
+                    console.warn('[sceneCreate] registerPrimitive failed', e);
+                }
+            }
+        } catch (e) {
+            console.error('[sceneCreate]', e);
+        }
+        return;
+    }
+    if (cmd === 'sceneDelete') {
+        // Lua: part:Destroy() → удаление примитива.
+        try {
+            const pm = runtime.scene3d?.primitiveManager;
+            if (!pm || typeof pm.removeInstance !== 'function') return;
+            const id = payload?.primId;
+            if (id != null) pm.removeInstance(Number(id));
+        } catch (e) {
+            console.error('[sceneDelete]', e);
+        }
+        return;
+    }
+    if (cmd === 'partVel') {
+        try {
+            const pm = runtime.scene3d?.primitiveManager;
+            if (pm && typeof pm.setVelocity === 'function') {
+                pm.setVelocity(payload.primId, payload.vx, payload.vy, payload.vz);
+            }
+        } catch (e) {}
+        return;
+    }
+    if (cmd === 'playerCmd') {
+        try {
+            const p = runtime.game?.player;
+            if (!p) return;
+            const method = payload?.method;
+            const args = payload?.args || [];
+            if (method === 'teleport') p.teleport && p.teleport(args[0], args[1], args[2]);
+            else if (method === 'setWalkSpeed') p.setWalkSpeed && p.setWalkSpeed(args[0]);
+            else if (method === 'setJumpPower') p.setJumpPower && p.setJumpPower(args[0]);
+            else if (method === 'setHealth') p.setHealth && p.setHealth(args[0]);
+            else if (method === 'die') p.die && p.die();
+            else if (method === 'damage' || method === 'takeDamage') p.damage && p.damage(args[0]);
+        } catch (e) {}
+        return;
+    }
+    if (cmd === 'guiUpdate') {
+        // TODO: scripts setting Visible/Text/Color on GUI → передать в GuiManager
+        return;
+    }
+}

tests/rbxl-lua-integration.test.js

@@ -0,0 +1,243 @@
+/**
+ * rbxl-lua-integration.test.js — реалистичные Roblox-сниппеты из obby/simulator карт.
+ */
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxApi } from '../src/engine/roblox-shim.js';
+import { RobloxScheduler } from '../src/engine/roblox-scheduler.js';
+import { installRobloxServices } from '../src/engine/roblox-services.js';
+import { RobloxTweenManager } from '../src/engine/roblox-tween.js';
+import { RobloxPhysicsManager } from '../src/engine/roblox-physics.js';
+
+function makeScene() {
+    return {
+        primitives: {
+            10: { id: 10, type: 'cube', name: 'KillPart', x: 5, y: 1, z: 0, sx: 4, sy: 1, sz: 4,
+                  color: '#ff0000', material: 'neon', anchored: true, canCollide: true, opacity: 1 },
+            11: { id: 11, type: 'cube', name: 'WinPart', x: 30, y: 1, z: 0, sx: 4, sy: 1, sz: 4,
+                  color: '#00ff00', material: 'neon', anchored: true, canCollide: true, opacity: 1 },
+            12: { id: 12, type: 'cube', name: 'Conveyor', x: 15, y: 1, z: 0, sx: 8, sy: 0.5, sz: 4,
+                  color: '#888888', material: 'metal', anchored: true, canCollide: true, opacity: 1 },
+            13: { id: 13, type: 'cube', name: 'Door', x: 20, y: 3, z: 0, sx: 2, sy: 6, sz: 4,
+                  color: '#a0522d', material: 'matte', anchored: true, canCollide: true, opacity: 1 },
+        },
+    };
+}
+
+const STORE = new Map();
+
+async function run(luaSource, targetPrimId = 10, ticks = []) {
+    const factory = new LuaFactory();
+    const lua = await factory.createEngine();
+    const sent = [];
+    const send = (cmd, payload) => sent.push({ cmd, payload });
+    let playerState = { x: 0, y: 5, z: 0, hp: 100 };
+    registerRobloxApi(lua, { getSceneSnap: makeScene, targetPrimitiveId: targetPrimId, send });
+    const sched = new RobloxScheduler(lua);
+    sched.install();
+    installRobloxServices(lua, {
+        send,
+        getPlayerState: () => playerState,
+        loadSave: (k) => STORE.get(k),
+        saveSave: (k, v) => STORE.set(k, v),
+        removeSave: (k) => STORE.delete(k),
+    });
+    const tween = new RobloxTweenManager();
+    tween.install(lua);
+    const phys = new RobloxPhysicsManager(send);
+    phys.install(lua);
+
+    await sched.spawnMain(luaSource);
+    for (const dt of ticks) {
+        await sched.tick(dt);
+        tween.tick(dt);
+        phys.tick(dt);
+    }
+    lua.global.close();
+    return {
+        logs: sent.filter(s => s.cmd === 'log').map(s => s.payload),
+        partSets: sent.filter(s => s.cmd === 'partSet').map(s => s.payload),
+        partVels: sent.filter(s => s.cmd === 'partVel').map(s => s.payload),
+        playerCmds: sent.filter(s => s.cmd === 'playerCmd').map(s => s.payload),
+    };
+}
+
+const TESTS = [
+    {
+        name: 'KillBrick (Touched → Humanoid.Health = 0)',
+        lua: `
+            local part = script.Parent
+            part.Touched:Connect(function(hit)
+                local hum = hit.Parent and hit.Parent:FindFirstChild("Humanoid")
+                if hum then hum.Health = 0 end
+            end)
+            print("kill brick armed")
+        `,
+        ticks: [],
+        check: (r) => r.logs.some(l => l.text === 'kill brick armed'),
+    },
+    {
+        name: 'WalkSpeed boost через trigger',
+        lua: `
+            local h = game:GetService("Players").LocalPlayer.Character.Humanoid
+            h.WalkSpeed = 32
+            print("speed boosted to", h.WalkSpeed)
+        `,
+        check: (r) => r.playerCmds.some(c => c.method === 'setWalkSpeed' && c.args[0] === 32)
+            && r.logs.some(l => l.text.includes('speed boosted')),
+    },
+    {
+        name: 'Door open: TweenService двигает дверь вверх',
+        lua: `
+            local door = workspace:FindFirstChild("Door")
+            local TS = game:GetService("TweenService")
+            local goal = { Position = Vector3.new(door.Position.X, door.Position.Y + 10, door.Position.Z) }
+            local info = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
+            local tw = TS:Create(door, info, goal)
+            tw:Play()
+            print("door opening")
+        `,
+        ticks: [0.5, 0.5, 0.1],
+        check: (r) => r.partSets.some(p => p.primId === 13 && p.prop === 'position'),
+    },
+    {
+        name: 'Конвейер: BodyVelocity толкает игрока',
+        lua: `
+            local conv = workspace:FindFirstChild("Conveyor")
+            local bv = Instance.new("BodyVelocity", conv)
+            bv.Velocity = Vector3.new(20, 0, 0)
+            bv.MaxForce = Vector3.new(4000, 0, 4000)
+            print("conveyor started")
+        `,
+        ticks: [0.1],
+        check: (r) => r.partVels.some(v => v.primId === 12 && v.vx === 20),
+    },
+    {
+        name: 'leaderstats (как в tycoon)',
+        lua: `
+            local Players = game:GetService("Players")
+            local plr = Players.LocalPlayer
+            local money = Instance.new("IntValue", plr.leaderstats)
+            money.Name = "Money"
+            money.Value = 100
+            print("money:", money.Value)
+        `,
+        check: (r) => r.logs.some(l => l.text === 'money:\t100'),
+    },
+    {
+        name: 'Checkpoint сохраняется в DataStore',
+        lua: `
+            local DSS = game:GetService("DataStoreService")
+            local store = DSS:GetDataStore("checkpoints")
+            store:SetAsync("player1", 5)
+            local cp = store:GetAsync("player1")
+            print("checkpoint:", cp)
+        `,
+        check: (r) => r.logs.some(l => l.text === 'checkpoint:\t5'),
+    },
+    {
+        name: 'Цикл с wait — подсчёт',
+        lua: `
+            for i = 1, 3 do
+                print("count:", i)
+                wait(0.3)
+            end
+            print("done")
+        `,
+        ticks: [0.3, 0.3, 0.3, 0.3],
+        check: (r) => {
+            const texts = r.logs.map(l => l.text);
+            return texts.includes('count:\t1') && texts.includes('count:\t2')
+                && texts.includes('count:\t3') && texts.includes('done');
+        },
+    },
+    {
+        name: 'task.spawn — параллельные функции',
+        lua: `
+            task.spawn(function() print("parallel A") end)
+            task.spawn(function() print("parallel B") end)
+            print("main")
+        `,
+        check: (r) => {
+            const texts = r.logs.map(l => l.text);
+            return texts.includes('parallel A') && texts.includes('parallel B') && texts.includes('main');
+        },
+    },
+    {
+        name: 'Color3 + Material смена при Touched',
+        lua: `
+            local part = workspace:FindFirstChild("KillPart")
+            part.Touched:Connect(function()
+                part.Color = Color3.fromRGB(0, 0, 255)
+                part.Material = "Neon"
+            end)
+            -- симулируем touch
+            part.Touched:Fire(workspace)
+        `,
+        check: (r) => r.partSets.some(p => p.primId === 10 && p.prop === 'color')
+            && r.partSets.some(p => p.primId === 10 && p.prop === 'material'),
+    },
+    {
+        name: 'RemoteEvent: client→server message',
+        lua: `
+            local re = Instance.new("RemoteEvent", workspace)
+            re.Name = "Coins"
+            re.OnServerEvent:Connect(function(player, amount)
+                print("server received:", amount)
+            end)
+            re:FireServer(50)
+        `,
+        check: (r) => r.logs.some(l => l.text === 'server received:\t50'),
+    },
+    {
+        name: 'Heartbeat: счётчик через RunService',
+        lua: `
+            local RS = game:GetService("RunService")
+            local count = 0
+            RS.Heartbeat:Connect(function(dt)
+                count = count + 1
+                if count == 3 then print("tick3") end
+            end)
+        `,
+        ticks: [0.1, 0.1, 0.1],
+        check: (r) => r.logs.some(l => l.text === 'tick3'),
+    },
+    {
+        name: 'Math: Vector3 arithmetic',
+        lua: `
+            local a = Vector3.new(1, 2, 3)
+            local b = Vector3.new(4, 5, 6)
+            local sum = a:add(b)
+            print("sum:", sum.X, sum.Y, sum.Z)
+            local d = a:Dot(b)
+            print("dot:", d)
+        `,
+        check: (r) => {
+            const texts = r.logs.map(l => l.text);
+            return texts.some(t => t === 'sum:\t5\t7\t9') && texts.some(t => t === 'dot:\t32');
+        },
+    },
+];
+
+(async () => {
+    let passed = 0, failed = 0;
+    for (const t of TESTS) {
+        try {
+            const r = await run(t.lua, t.targetPrimId, t.ticks || []);
+            const ok = t.check(r);
+            if (ok) { console.log(`✓ ${t.name}`); passed++; }
+            else {
+                console.log(`✗ ${t.name}`);
+                console.log(`    logs: ${JSON.stringify(r.logs.map(l => l.text))}`);
+                if (r.partSets.length) console.log(`    partSets: ${JSON.stringify(r.partSets)}`);
+                if (r.partVels.length) console.log(`    partVels: ${JSON.stringify(r.partVels)}`);
+                if (r.playerCmds.length) console.log(`    playerCmds: ${JSON.stringify(r.playerCmds)}`);
+                failed++;
+            }
+        } catch (e) {
+            console.log(`✗ ${t.name} — exception: ${e.message || e}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();

tests/rbxl-lua-mvp.test.js

@@ -0,0 +1,187 @@
+/**
+ * rbxl-lua-mvp.test.js — headless smoke-тест Roblox Lua API shim.
+ *
+ * НЕ запускает Worker (это требует браузерного Worker API). Вместо этого
+ * напрямую импортирует roblox-shim.js и инициализирует Lua в текущем потоке.
+ *
+ * Запуск: node --experimental-vm-modules tests/rbxl-lua-mvp.test.js
+ */
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxApi } from '../src/engine/roblox-shim.js';
+
+const FAKE_SCENE_SNAP = {
+    primitives: {
+        1: { id: 1, type: 'cube', name: 'Floor', x: 0, y: 0, z: 0, sx: 10, sy: 1, sz: 10,
+             color: '#888888', material: 'glossy', anchored: true, canCollide: true, opacity: 1 },
+        2: { id: 2, type: 'cube', name: 'KillBrick', x: 5, y: 1, z: 0, sx: 2, sy: 1, sz: 2,
+             color: '#ff0000', material: 'neon', anchored: true, canCollide: true, opacity: 1 },
+    },
+};
+
+const SNIPPETS = [
+    {
+        name: 'print hello',
+        lua: `print("Hello from Lua!")`,
+        expectLogs: [{ level: 'info', text: 'Hello from Lua!' }],
+    },
+    {
+        name: 'Vector3 math',
+        lua: `
+            local v = Vector3.new(3, 4, 0)
+            print("magnitude:", v.Magnitude)
+            local u = v.Unit
+            print("unit:", u.X, u.Y, u.Z)
+        `,
+        expectLogs: [
+            { level: 'info', text: 'magnitude:\t5' },
+        ],
+    },
+    {
+        name: 'workspace iteration',
+        lua: `
+            local children = workspace:GetChildren()
+            print("count:", #children)
+            for i, c in ipairs(children) do
+                print("child:", c.Name, "class:", c.ClassName)
+            end
+        `,
+        expectLogs: [
+            { level: 'info', text: 'count:\t2' },
+        ],
+    },
+    {
+        name: 'FindFirstChild',
+        lua: `
+            local kb = workspace:FindFirstChild("KillBrick")
+            if kb then print("found:", kb.Name)
+            else print("not found") end
+        `,
+        expectLogs: [{ level: 'info', text: 'found:\tKillBrick' }],
+    },
+    {
+        name: 'Part.Position get',
+        lua: `
+            local kb = workspace:FindFirstChild("KillBrick")
+            print("position:", kb.Position.X, kb.Position.Y, kb.Position.Z)
+        `,
+        expectLogs: [{ level: 'info', text: 'position:\t5\t1\t0' }],
+    },
+    {
+        name: 'Part.Color set',
+        lua: `
+            local kb = workspace:FindFirstChild("KillBrick")
+            kb.Color = Color3.new(0, 1, 0)
+            print("new color hex (via Position):", kb.Color.R, kb.Color.G, kb.Color.B)
+        `,
+        expectPartSet: { primId: 2, prop: 'color' },
+    },
+    {
+        name: 'CFrame.Angles',
+        lua: `
+            local cf = CFrame.Angles(0, math.pi/2, 0)
+            print("lookvector:", cf.LookVector.X, cf.LookVector.Y, cf.LookVector.Z)
+        `,
+        expectLogs: [],
+    },
+    {
+        name: 'Instance.new + Parent',
+        lua: `
+            local f = Instance.new("Folder", workspace)
+            f.Name = "MyFolder"
+            print("folder name:", f.Name, "parent:", f.Parent.Name)
+        `,
+        expectLogs: [{ level: 'info', text: 'folder name:\tMyFolder\tparent:\tWorkspace' }],
+    },
+    {
+        name: 'IsA hierarchy',
+        lua: `
+            local kb = workspace:FindFirstChild("KillBrick")
+            print("isa Part:", kb:IsA("Part"))
+            print("isa BasePart:", kb:IsA("BasePart"))
+            print("isa Instance:", kb:IsA("Instance"))
+            print("isa Sound:", kb:IsA("Sound"))
+        `,
+        expectLogs: [
+            { level: 'info', text: 'isa Part:\ttrue' },
+            { level: 'info', text: 'isa BasePart:\ttrue' },
+            { level: 'info', text: 'isa Instance:\ttrue' },
+            { level: 'info', text: 'isa Sound:\tfalse' },
+        ],
+    },
+];
+
+async function runSnippet(snippet) {
+    const factory = new LuaFactory();
+    const lua = await factory.createEngine();
+
+    const logs = [];
+    const sent = [];
+    const send = (cmd, payload) => sent.push({ cmd, payload });
+
+    registerRobloxApi(lua, {
+        getSceneSnap: () => FAKE_SCENE_SNAP,
+        targetPrimitiveId: 2,    // как будто скрипт прикреплён к KillBrick
+        send,
+    });
+
+    // Перехват print через send('log', ...)
+    let errMsg = null;
+    try {
+        await lua.doString(snippet.lua);
+    } catch (e) {
+        errMsg = e && e.message ? e.message : String(e);
+    }
+    lua.global.close();
+
+    const captured = sent.filter(s => s.cmd === 'log');
+    return { logs: captured.map(s => s.payload), partSets: sent.filter(s => s.cmd === 'partSet'), error: errMsg };
+}
+
+(async () => {
+    let passed = 0;
+    let failed = 0;
+    for (const s of SNIPPETS) {
+        const result = await runSnippet(s);
+        const ok = checkExpectations(s, result);
+        if (ok.success) {
+            console.log(`✓ ${s.name}`);
+            passed++;
+        } else {
+            console.log(`✗ ${s.name}`);
+            console.log(`    error: ${result.error || 'none'}`);
+            console.log(`    logs received:`);
+            for (const l of result.logs) console.log(`      [${l.level}] ${JSON.stringify(l.text)}`);
+            if (result.partSets.length) {
+                console.log(`    partSets:`, JSON.stringify(result.partSets));
+            }
+            console.log(`    reason: ${ok.reason}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();
+
+function checkExpectations(snippet, result) {
+    if (result.error) {
+        return { success: false, reason: `lua error: ${result.error}` };
+    }
+    if (snippet.expectLogs) {
+        for (const exp of snippet.expectLogs) {
+            const found = result.logs.find(l => l.level === exp.level && l.text === exp.text);
+            if (!found) {
+                return { success: false, reason: `missing log: [${exp.level}] ${JSON.stringify(exp.text)}` };
+            }
+        }
+    }
+    if (snippet.expectPartSet) {
+        const found = result.partSets.find(s =>
+            s.payload.primId === snippet.expectPartSet.primId &&
+            s.payload.prop === snippet.expectPartSet.prop
+        );
+        if (!found) {
+            return { success: false, reason: `missing partSet ${JSON.stringify(snippet.expectPartSet)}` };
+        }
+    }
+    return { success: true };
+}

tests/rbxl-lua-services.test.js

@@ -0,0 +1,144 @@
+/**
+ * rbxl-lua-services.test.js — тесты Humanoid, RemoteEvent, DataStore, HttpService.
+ */
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxApi } from '../src/engine/roblox-shim.js';
+import { RobloxScheduler } from '../src/engine/roblox-scheduler.js';
+import { installRobloxServices } from '../src/engine/roblox-services.js';
+
+const SCENE = { primitives: {} };
+
+const STORE = new Map();
+
+async function run(luaSource, ticks = []) {
+    const factory = new LuaFactory();
+    const lua = await factory.createEngine();
+    const sent = [];
+    const send = (cmd, payload) => sent.push({ cmd, payload });
+    let playerState = { x: 0, y: 5, z: 0 };
+
+    registerRobloxApi(lua, { getSceneSnap: () => SCENE, targetPrimitiveId: null, send });
+    const sched = new RobloxScheduler(lua);
+    sched.install();
+    installRobloxServices(lua, {
+        send,
+        getPlayerState: () => playerState,
+        loadSave: (k) => STORE.get(k),
+        saveSave: (k, v) => STORE.set(k, v),
+        removeSave: (k) => STORE.delete(k),
+    });
+
+    await sched.spawnMain(luaSource);
+    for (const dt of ticks) await sched.tick(dt);
+    lua.global.close();
+    return { logs: sent.filter(s => s.cmd === 'log').map(s => s.payload),
+             playerCmds: sent.filter(s => s.cmd === 'playerCmd').map(s => s.payload),
+             broadcasts: sent.filter(s => s.cmd === 'broadcast').map(s => s.payload) };
+}
+
+const TESTS = [
+    {
+        name: 'Players.LocalPlayer.Character.Humanoid существует',
+        lua: `
+            local p = game:GetService("Players").LocalPlayer
+            local h = p.Character:WaitForChild("Humanoid")
+            print("hp:", h.Health, "ws:", h.WalkSpeed)
+        `,
+        expect: [{ level: 'info', text: 'hp:\t100\tws:\t16' }],
+    },
+    {
+        name: 'Humanoid.WalkSpeed = 50 → playerCmd setWalkSpeed',
+        lua: `
+            local h = game:GetService("Players").LocalPlayer.Character.Humanoid
+            h.WalkSpeed = 50
+        `,
+        expectPlayerCmd: { method: 'setWalkSpeed', argsCheck: (a) => a[0] === 50 },
+    },
+    {
+        name: 'Humanoid:TakeDamage уменьшает HP',
+        lua: `
+            local h = game:GetService("Players").LocalPlayer.Character.Humanoid
+            h:TakeDamage(30)
+            print("after damage:", h.Health)
+        `,
+        expect: [{ level: 'info', text: 'after damage:\t70' }],
+    },
+    {
+        name: 'Humanoid.Health = 0 → Died fires',
+        lua: `
+            local h = game:GetService("Players").LocalPlayer.Character.Humanoid
+            h.Died:Connect(function() print("DIED") end)
+            h.Health = 0
+        `,
+        expect: [{ level: 'info', text: 'DIED' }],
+    },
+    {
+        name: 'DataStoreService GetAsync/SetAsync',
+        lua: `
+            local DSS = game:GetService("DataStoreService")
+            local store = DSS:GetDataStore("coins")
+            store:SetAsync("player1", 100)
+            print("got:", store:GetAsync("player1"))
+        `,
+        expect: [{ level: 'info', text: 'got:\t100' }],
+    },
+    {
+        name: 'DataStoreService IncrementAsync',
+        lua: `
+            local store = game:GetService("DataStoreService"):GetDataStore("score")
+            store:SetAsync("p1", 50)
+            store:IncrementAsync("p1", 25)
+            print("final:", store:GetAsync("p1"))
+        `,
+        expect: [{ level: 'info', text: 'final:\t75' }],
+    },
+    {
+        name: 'HttpService:JSONEncode/Decode',
+        lua: `
+            local HS = game:GetService("HttpService")
+            local s = HS:JSONEncode({a=1, b="two"})
+            print("encoded len:", #s)
+            local d = HS:JSONDecode('{"x":42}')
+            print("decoded x:", d.x)
+        `,
+        expect: [{ level: 'info', text: 'decoded x:\t42' }],
+    },
+    {
+        name: 'RemoteEvent FireServer + OnServerEvent',
+        lua: `
+            local re = Instance.new("RemoteEvent", workspace)
+            re.Name = "MyEvent"
+            re.OnServerEvent:Connect(function(player, msg)
+                print("server got:", msg)
+            end)
+            re:FireServer("hello")
+        `,
+        expect: [{ level: 'info', text: 'server got:\thello' }],
+    },
+];
+
+(async () => {
+    let passed = 0, failed = 0;
+    for (const t of TESTS) {
+        try {
+            const r = await run(t.lua, t.ticks);
+            let ok = true; let reason = '';
+            for (const exp of (t.expect || [])) {
+                const found = r.logs.find(l => l.level === exp.level && l.text === exp.text);
+                if (!found) { ok = false; reason = `missing log: ${exp.text}; got: ${JSON.stringify(r.logs)}`; break; }
+            }
+            if (t.expectPlayerCmd) {
+                const found = r.playerCmds.find(c => c.method === t.expectPlayerCmd.method
+                    && (!t.expectPlayerCmd.argsCheck || t.expectPlayerCmd.argsCheck(c.args)));
+                if (!found) { ok = false; reason = `missing playerCmd ${t.expectPlayerCmd.method}; got: ${JSON.stringify(r.playerCmds)}`; }
+            }
+            if (ok) { console.log(`✓ ${t.name}`); passed++; }
+            else { console.log(`✗ ${t.name} — ${reason}`); failed++; }
+        } catch (e) {
+            console.log(`✗ ${t.name} — exception: ${e.message || e}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();

tests/rbxl-lua-tween.test.js

@@ -0,0 +1,89 @@
+/**
+ * rbxl-lua-tween.test.js — тесты TweenService.
+ */
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxApi } from '../src/engine/roblox-shim.js';
+import { RobloxScheduler } from '../src/engine/roblox-scheduler.js';
+import { RobloxTweenManager } from '../src/engine/roblox-tween.js';
+
+const SCENE = {
+    primitives: {
+        1: { id: 1, type: 'cube', name: 'Movable', x: 0, y: 5, z: 0, sx: 1, sy: 1, sz: 1,
+             color: '#ffffff', material: 'glossy', anchored: false, canCollide: true, opacity: 1 },
+    },
+};
+
+async function run(luaSource, ticks = []) {
+    const factory = new LuaFactory();
+    const lua = await factory.createEngine();
+    const sent = [];
+    const send = (cmd, payload) => sent.push({ cmd, payload });
+    registerRobloxApi(lua, { getSceneSnap: () => SCENE, targetPrimitiveId: 1, send });
+    const sched = new RobloxScheduler(lua);
+    sched.install();
+    const tweenMgr = new RobloxTweenManager();
+    tweenMgr.install(lua);
+
+    await sched.spawnMain(luaSource);
+    for (const dt of ticks) {
+        await sched.tick(dt);
+        tweenMgr.tick(dt);
+    }
+    lua.global.close();
+    return { logs: sent.filter(s => s.cmd === 'log').map(s => s.payload),
+             partSets: sent.filter(s => s.cmd === 'partSet').map(s => s.payload) };
+}
+
+const TESTS = [
+    {
+        name: 'TweenInfo создаётся',
+        lua: `
+            local info = TweenInfo.new(2, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
+            print("time:", info.Time, "style:", info.EasingStyle)
+        `,
+        ticks: [],
+        expectLogs: [{ level: 'info', text: 'time:\t2\tstyle:\tLinear' }],
+    },
+    {
+        name: 'TweenService:Create + Play (Linear)',
+        lua: `
+            local TS = game:GetService("TweenService")
+            local p = workspace:FindFirstChild("Movable")
+            local info = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
+            local tw = TS:Create(p, info, { Position = Vector3.new(10, 5, 0) })
+            tw:Play()
+            print("started")
+        `,
+        ticks: [0.5, 0.5, 0.1],  // больше 1 сек — должен завершиться
+        // Ожидаем что хотя бы один partSet с prop=position
+        expectPartSet: { primId: 1, prop: 'position' },
+    },
+];
+
+(async () => {
+    let passed = 0, failed = 0;
+    for (const t of TESTS) {
+        try {
+            const r = await run(t.lua, t.ticks);
+            let ok = true;
+            let reason = '';
+            for (const exp of (t.expectLogs || [])) {
+                const found = r.logs.find(l => l.level === exp.level && l.text === exp.text);
+                if (!found) { ok = false; reason = `missing log: ${exp.text}`; break; }
+            }
+            if (t.expectPartSet) {
+                const found = r.partSets.find(p => p.primId === t.expectPartSet.primId && p.prop === t.expectPartSet.prop);
+                if (!found) {
+                    ok = false; reason = `missing partSet: ${JSON.stringify(t.expectPartSet)}; got: ${JSON.stringify(r.partSets.slice(0,3))}`;
+                }
+            }
+            if (ok) { console.log(`✓ ${t.name}`); passed++; }
+            else { console.log(`✗ ${t.name} — ${reason}`); failed++; }
+        } catch (e) {
+            console.log(`✗ ${t.name} — exception: ${e}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();

tests/rbxl-lua-wait.test.js

@@ -0,0 +1,104 @@
+/**
+ * rbxl-lua-wait.test.js — тесты wait/task.wait через шедулер.
+ */
+import { LuaFactory } from 'wasmoon';
+import { registerRobloxApi } from '../src/engine/roblox-shim.js';
+import { RobloxScheduler } from '../src/engine/roblox-scheduler.js';
+
+const SCENE = { primitives: {} };
+
+async function run(luaSource, ticks = [0.5, 0.5, 0.5, 0.5, 0.5]) {
+    const factory = new LuaFactory();
+    const lua = await factory.createEngine();
+    const sent = [];
+    const send = (cmd, payload) => sent.push({ cmd, payload });
+    registerRobloxApi(lua, { getSceneSnap: () => SCENE, targetPrimitiveId: null, send });
+    const sched = new RobloxScheduler(lua);
+    sched.install();
+
+    await sched.spawnMain(luaSource);
+    for (const dt of ticks) {
+        await sched.tick(dt);
+    }
+    lua.global.close();
+    return sent.filter(s => s.cmd === 'log').map(s => s.payload);
+}
+
+const TESTS = [
+    {
+        name: 'wait(0) — мгновенный',
+        lua: `
+            print("before")
+            wait(0)
+            print("after")
+        `,
+        expect: ['before', 'after'],
+    },
+    {
+        name: 'wait(1) — резюм после tick',
+        lua: `
+            print("step1")
+            wait(1)
+            print("step2")
+        `,
+        ticks: [0.5, 0.5, 0.5],   // 1.5 сек суммарно
+        expect: ['step1', 'step2'],
+    },
+    {
+        name: 'task.wait(0.5)',
+        lua: `
+            print("a")
+            task.wait(0.5)
+            print("b")
+        `,
+        ticks: [0.5, 0.5],
+        expect: ['a', 'b'],
+    },
+    {
+        name: 'несколько wait подряд',
+        lua: `
+            print("p1")
+            wait(0.5)
+            print("p2")
+            wait(0.5)
+            print("p3")
+        `,
+        ticks: [0.5, 0.5, 0.5, 0.5],   // 2 сек
+        expect: ['p1', 'p2', 'p3'],
+    },
+    {
+        name: 'task.delay (не блокирует)',
+        lua: `
+            print("immediate")
+            task.delay(0.3, function() print("delayed") end)
+            print("after delay-call")
+        `,
+        ticks: [0.5],
+        expect: ['immediate', 'after delay-call', 'delayed'],
+    },
+];
+
+(async () => {
+    let passed = 0, failed = 0;
+    for (const t of TESTS) {
+        try {
+            const logs = await run(t.lua, t.ticks);
+            const texts = logs.map(l => l.text);
+            const ok = JSON.stringify(texts) === JSON.stringify(t.expect);
+            if (ok) {
+                console.log(`✓ ${t.name}`);
+                passed++;
+            } else {
+                console.log(`✗ ${t.name}`);
+                console.log(`    expected: ${JSON.stringify(t.expect)}`);
+                console.log(`    got:      ${JSON.stringify(texts)}`);
+                failed++;
+            }
+        } catch (e) {
+            console.log(`✗ ${t.name} — exception: ${e}`);
+            failed++;
+        }
+    }
+    console.log(`\n${passed} passed, ${failed} failed`);
+    process.exit(failed > 0 ? 1 : 0);
+})();