npm - @aiyiran/myclaw - Versions diffs - 1.1.83 → 1.1.85 - Mend

@aiyiran/myclaw 1.1.83 → 1.1.85

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/a/1.html ADDED Viewed

@@ -0,0 +1,842 @@
+<!DOCTYPE html>
+<html lang="zh">
+<head>
+    <meta charset="UTF-8">
+    <title>3D 迷宫</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            overflow: hidden;
+        }
+        canvas {
+            display: block;
+        }
+        #info {
+            position: absolute;
+            bottom: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            color: white;
+            font-family: sans-serif;
+            font-size: 14px;
+            text-align: center;
+            background: rgba(0, 0, 0, 0.5);
+            padding: 10px 20px;
+            border-radius: 8px;
+        }
+        #control-panel {
+            position: absolute;
+            top: 20px;
+            left: 20px;
+            background: rgba(0, 0, 0, 0.7);
+            border-radius: 12px;
+            padding: 15px;
+            color: white;
+            font-family: sans-serif;
+            min-width: 160px;
+        }
+        #control-panel h3 {
+            margin-bottom: 12px;
+            font-size: 14px;
+            color: #aaa;
+            text-align: center;
+        }
+        .view-btn {
+            display: block;
+            width: 100%;
+            padding: 10px 15px;
+            margin-bottom: 8px;
+            border: 2px solid transparent;
+            border-radius: 8px;
+            background: rgba(255, 255, 255, 0.1);
+            color: white;
+            font-size: 14px;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        .view-btn:hover {
+            background: rgba(255, 255, 255, 0.2);
+        }
+        .view-btn.active {
+            border-color: #4a90d9;
+            background: rgba(74, 144, 217, 0.3);
+        }
+        .view-icon {
+            margin-right: 8px;
+        }
+        #win-message {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.9);
+            border: 3px solid #ffd43b;
+            border-radius: 20px;
+            padding: 40px 60px;
+            color: white;
+            font-family: sans-serif;
+            text-align: center;
+            display: none;
+        }
+        #win-message h2 {
+            color: #ffd43b;
+            font-size: 32px;
+            margin-bottom: 15px;
+        }
+        #win-message p {
+            font-size: 16px;
+            color: #aaa;
+        }
+        #restart-btn {
+            margin-top: 20px;
+            padding: 12px 30px;
+            font-size: 16px;
+            background: #51cf66;
+            border: none;
+            border-radius: 8px;
+            color: white;
+            cursor: pointer;
+        }
+        #restart-btn:hover {
+            background: #40a854;
+        }
+        #lives-display {
+            position: absolute;
+            top: 20px;
+            right: 20px;
+            font-size: 32px;
+            background: rgba(0, 0, 0, 0.7);
+            padding: 10px 20px;
+            border-radius: 12px;
+        }
+        #game-over-message {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(20, 0, 0, 0.95);
+            border: 3px solid #8B0000;
+            border-radius: 20px;
+            padding: 40px 60px;
+            color: white;
+            font-family: 'Courier New', monospace;
+            text-align: center;
+            display: none;
+            box-shadow: 0 0 50px rgba(139, 0, 0, 0.8), inset 0 0 30px rgba(0, 0, 0, 0.5);
+            animation: horrorPulse 1s infinite;
+        }
+        @keyframes horrorPulse {
+            0%,
+            100% {
+                box-shadow: 0 0 50px rgba(139, 0, 0, 0.8), inset 0 0 30px rgba(0, 0, 0, 0.5);
+            }
+            50% {
+                box-shadow: 0 0 80px rgba(139, 0, 0, 1), inset 0 0 50px rgba(0, 0, 0, 0.8);
+            }
+        }
+        #game-over-message h2 {
+            color: #ff0000;
+            font-size: 42px;
+            margin-bottom: 15px;
+            text-shadow: 0 0 20px #ff0000, 0 0 40px #ff0000;
+            animation: textFlicker 0.5s infinite;
+        }
+        @keyframes textFlicker {
+            0%,
+            100% {
+                opacity: 1;
+            }
+            50% {
+                opacity: 0.8;
+            }
+        }
+        #game-over-message p {
+            font-size: 18px;
+            color: #ccc;
+            text-shadow: 0 0 10px rgba(255, 0, 0, 0.5);
+        }
+        #restart-btn-gameover {
+            margin-top: 20px;
+            padding: 12px 30px;
+            font-size: 16px;
+            background: #ff4444;
+            border: none;
+            border-radius: 8px;
+            color: white;
+            cursor: pointer;
+        }
+        #restart-btn-gameover:hover {
+            background: #cc0000;
+        }
+        /* 危险特效遮罩 */
+        #danger-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 1000;
+            opacity: 0;
+            transition: opacity 0.1s;
+        }
+    </style>
+</head>
+<body>
+    <!-- 全屏特效遮罩 -->
+    <div id="danger-overlay"></div>
+    <div id="control-panel">
+        <h3>📷 视角切换</h3>
+        <button class="view-btn active" id="btn-free">
+            <span class="view-icon">🎥</span>自由视角
+        </button>
+        <button class="view-btn" id="btn-immersive">
+            <span class="view-icon">👁️</span>身临其境
+        </button>
+    </div>
+    <div id="info">
+        🏁 找到黄色旗帜走出迷宫! 小心僵尸!<br>
+        <b>WASD</b> = 移动 | <b>方向键</b> = 控制视角
+    </div>
+    <div id="lives-display">
+        ❤️❤️❤️
+    </div>
+    <div id="game-over-message">
+        <h2>💀 游戏结束!</h2>
+        <p>你被僵尸抓住了...</p>
+        <button id="restart-btn-gameover">再来一局</button>
+    </div>
+    <div id="win-message">
+        <h2>🎉 恭喜通关!</h2>
+        <p>你成功走出了迷宫!</p>
+        <button id="restart-btn">再来一局</button>
+    </div>
+    <script type="importmap">
+    {
+        "imports": {
+            "three": "https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js",
+            "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/"
+        }
+    }
+    </script>
+    <script type="module">
+        import * as THREE from 'three';
+        import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+        // ============ 迷宫配置 ============
+        const MAZE_SIZE = 11;        // 迷宫格子数(奇数)
+        const CELL_SIZE = 4;         // 每格大小
+        const WALL_HEIGHT = 3;       // 墙高度
+        const PLAYER_RADIUS = 0.5;   // 玩家半径
+        const MOVE_SPEED = 0.15;     // 移动速度
+        // ============ 全局变量 ============
+        let scene, camera, renderer, orbitControls;
+        let playerSphere, endFlag;
+        let zombie;
+        let walls = [];
+        let mazeData = [];
+        let viewMode = 'free';
+        let gameWon = false;
+        let gameOver = false;
+        // 生命系统
+        let playerLives = 3;
+        let isInvincible = false;  // 无敌时间
+        let invincibilityTimer = 0;
+        // WASD 控制移动,方向键控制视角
+        const keys = {
+            KeyW: false, KeyS: false, KeyA: false, KeyD: false,
+            ArrowUp: false, ArrowDown: false, ArrowLeft: false, ArrowRight: false
+        };
+        // ============ 初始化 ============
+        function init() {
+            // 创建场景
+            scene = new THREE.Scene();
+            scene.background = new THREE.Color(0x1a1a2e);
+            // 创建相机
+            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+            camera.position.set(0, 15, 15);
+            // 创建渲染器
+            renderer = new THREE.WebGLRenderer({ antialias: true });
+            renderer.setSize(window.innerWidth, window.innerHeight);
+            renderer.setPixelRatio(window.devicePixelRatio);
+            document.body.appendChild(renderer.domElement);
+            // 轨道控制器
+            orbitControls = new OrbitControls(camera, renderer.domElement);
+            orbitControls.enableDamping = true;
+            orbitControls.maxPolarAngle = Math.PI / 2 + 0.1;
+            // 生成迷宫
+            generateMaze();
+            // 创建地面
+            createGround();
+            // 创建墙壁
+            createWalls();
+            // 创建玩家
+            createPlayer();
+            // 创建终点
+            createEndFlag();
+            // 灯光
+            createLights();
+            // 创建僵尸
+            createZombie();
+            // 事件监听
+            setupEventListeners();
+        }
+        // ============ 迷宫生成(递归回溯算法) ============
+        function generateMaze() {
+            // 初始化迷宫数据(全为墙)
+            mazeData = [];
+            for (let z = 0; z < MAZE_SIZE; z++) {
+                mazeData[z] = [];
+                for (let x = 0; x < MAZE_SIZE; x++) {
+                    mazeData[z][x] = 1; // 1 = 墙
+                }
+            }
+            // 递归回溯生成迷宫
+            function carve(x, z) {
+                mazeData[z][x] = 0; // 0 = 路
+                // 随机方向
+                const directions = [
+                    [0, -2], [0, 2], [-2, 0], [2, 0]
+                ].sort(() => Math.random() - 0.5);
+                for (const [dx, dz] of directions) {
+                    const nx = x + dx;
+                    const nz = z + dz;
+                    if (nx > 0 && nx < MAZE_SIZE - 1 && nz > 0 && nz < MAZE_SIZE - 1 && mazeData[nz][nx] === 1) {
+                        // 打通中间的墙
+                        mazeData[z + dz / 2][x + dx / 2] = 0;
+                        carve(nx, nz);
+                    }
+                }
+            }
+            // 从角落开始生成
+            carve(1, 1);
+            // 确保起点和终点是路
+            mazeData[1][1] = 0;
+            mazeData[MAZE_SIZE - 2][MAZE_SIZE - 2] = 0;
+        }
+        // ============ 创建地面 ============
+        function createGround() {
+            const groundSize = MAZE_SIZE * CELL_SIZE + 10;
+            const groundGeometry = new THREE.PlaneGeometry(groundSize, groundSize);
+            const groundMaterial = new THREE.MeshStandardMaterial({
+                color: 0x1a3a1a,  // 深绿色地板
+                side: THREE.DoubleSide
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            ground.position.y = -0.5;
+            scene.add(ground);
+        }
+        // ============ 创建墙壁 ============
+        function createWalls() {
+            const wallMaterial = new THREE.MeshStandardMaterial({
+                color: 0x8B4513,  // 棕色墙壁(像砖墙)
+                metalness: 0.2,
+                roughness: 0.8
+            });
+            for (let z = 0; z < MAZE_SIZE; z++) {
+                for (let x = 0; x < MAZE_SIZE; x++) {
+                    if (mazeData[z][x] === 1) {
+                        const wallGeometry = new THREE.BoxGeometry(CELL_SIZE, WALL_HEIGHT, CELL_SIZE);
+                        const wall = new THREE.Mesh(wallGeometry, wallMaterial);
+                        wall.position.set(
+                            x * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2,
+                            WALL_HEIGHT / 2 - 0.5,
+                            z * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2
+                        );
+                        scene.add(wall);
+                        walls.push(wall);
+                    }
+                }
+            }
+        }
+        // ============ 创建玩家 ============
+        function createPlayer() {
+            const geometry = new THREE.SphereGeometry(PLAYER_RADIUS, 32, 32);
+            const material = new THREE.MeshStandardMaterial({
+                color: 0x4a90d9,
+                metalness: 0.3,
+                roughness: 0.4
+            });
+            playerSphere = new THREE.Mesh(geometry, material);
+            // 起点位置
+            playerSphere.position.set(
+                1 * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2,
+                PLAYER_RADIUS - 0.5,
+                1 * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2
+            );
+            scene.add(playerSphere);
+        }
+        // ============ 创建终点旗帜 ============
+        function createEndFlag() {
+            // 旗杆
+            const poleGeometry = new THREE.CylinderGeometry(0.1, 0.1, 2, 16);
+            const poleMaterial = new THREE.MeshStandardMaterial({ color: 0x8B4513 });
+            const pole = new THREE.Mesh(poleGeometry, poleMaterial);
+            // 红旗(黄色)
+            const flagGeometry = new THREE.PlaneGeometry(1.5, 1);
+            const flagMaterial = new THREE.MeshStandardMaterial({
+                color: 0xffdd00,
+                side: THREE.DoubleSide
+            });
+            const flag = new THREE.Mesh(flagGeometry, flagMaterial);
+            flag.position.set(0.75, 0.5, 0);
+            flag.rotation.y = Math.PI / 4;
+            endFlag = new THREE.Group();
+            endFlag.add(pole);
+            endFlag.add(flag);
+            // 终点位置
+            const endX = (MAZE_SIZE - 2) * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+            const endZ = (MAZE_SIZE - 2) * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+            endFlag.position.set(endX, 0, endZ);
+            scene.add(endFlag);
+        }
+        // ============ 创建僵尸 ============
+        function createZombie() {
+            // 身体(红色方块)
+            const bodyGeometry = new THREE.BoxGeometry(0.8, 1.5, 0.6);
+            const bodyMaterial = new THREE.MeshStandardMaterial({
+                color: 0x8B0000,
+                metalness: 0.1,
+                roughness: 0.9
+            });
+            const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
+            // 头
+            const headGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5);
+            const headMaterial = new THREE.MeshStandardMaterial({
+                color: 0xB22222,
+                metalness: 0.1,
+                roughness: 0.9
+            });
+            const head = new THREE.Mesh(headGeometry, headMaterial);
+            head.position.y = 1;
+            // 眼睛(黄色发光)
+            const eyeGeometry = new THREE.SphereGeometry(0.08, 16, 16);
+            const eyeMaterial = new THREE.MeshStandardMaterial({ color: 0xffff00, emissive: 0xffff00, emissiveIntensity: 0.5 });
+            const leftEye = new THREE.Mesh(eyeGeometry, eyeMaterial);
+            leftEye.position.set(-0.12, 1.05, 0.25);
+            const rightEye = new THREE.Mesh(eyeGeometry, eyeMaterial);
+            rightEye.position.set(0.12, 1.05, 0.25);
+            zombie = new THREE.Group();
+            zombie.add(body);
+            zombie.add(head);
+            zombie.add(leftEye);
+            zombie.add(rightEye);
+            // 找到有效的随机位置(路上,不是墙)
+            let validPositions = [];
+            for (let z = 0; z < MAZE_SIZE; z++) {
+                for (let x = 0; x < MAZE_SIZE; x++) {
+                    if (mazeData[z][x] === 0) {
+                        // 计算世界坐标
+                        const worldX = x * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+                        const worldZ = z * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+                        // 排除起点附近(距离起点大于5格)
+                        const distToPlayer = Math.sqrt(
+                            Math.pow(worldX - playerSphere.position.x, 2) +
+                            Math.pow(worldZ - playerSphere.position.z, 2)
+                        );
+                        if (distToPlayer > CELL_SIZE * 4) {
+                            validPositions.push({ x: worldX, z: worldZ });
+                        }
+                    }
+                }
+            }
+            // 随机选一个位置
+            const pos = validPositions[Math.floor(Math.random() * validPositions.length)];
+            zombie.position.set(pos.x, 0.25, pos.z);
+            scene.add(zombie);
+        }
+        // ============ 创建灯光 ============
+        function createLights() {
+            const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+            scene.add(ambientLight);
+            const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+            directionalLight.position.set(10, 20, 10);
+            scene.add(directionalLight);
+        }
+        // ============ 碰撞检测 ============
+        const raycaster = new THREE.Raycaster();
+        function canMoveTo(position, direction, distance) {
+            raycaster.set(position, direction);
+            raycaster.far = distance + PLAYER_RADIUS;
+            const intersects = raycaster.intersectObjects(walls);
+            if (intersects.length > 0) {
+                return Math.max(0, intersects[0].distance - PLAYER_RADIUS * 0.3);
+            }
+            return distance;
+        }
+        // ============ 僵尸穿墙碰撞检测 ============
+        // 僵尸可以穿墙,但穿过墙时速度会变慢
+        const ZOMBIE_RADIUS = 0.5;
+        const ZOMBIE_SPEED_NORMAL = MOVE_SPEED * 0.5;      // 正常速度
+        const ZOMBIE_SPEED_WALL = MOVE_SPEED * 0.15;       // 穿墙时速度(很慢)
+        function isZombieInWall(position) {
+            // 检测位置是否在墙里面
+            raycaster.set(position, new THREE.Vector3(0, 0, 1));
+            raycaster.far = 10;
+            const intersects = raycaster.intersectObjects(walls);
+            // 如果前方很近就有墙,说明在墙里面
+            if (intersects.length > 0 && intersects[0].distance < CELL_SIZE * 0.8) {
+                return true;
+            }
+            return false;
+        }
+        function canZombieMove(position, direction, distance) {
+            // 僵尸可以穿墙,所以直接返回可以移动
+            // 但返回的距离会考虑是否在墙里
+            const inWall = isZombieInWall(position);
+            const speed = inWall ? ZOMBIE_SPEED_WALL : ZOMBIE_SPEED_NORMAL;
+            const actualDistance = Math.min(distance, speed);
+            return { canMove: true, distance: actualDistance, inWall: inWall };
+        }
+        // ============ 身临其境模式鼠标控制 ============
+        let isDragging = false;
+        let previousMousePosition = { x: 0, y: 0 };
+        let cameraRotationY = Math.PI; // 默认朝向 -Z 方向
+        let cameraRotationX = 0;
+        // ============ 更新生命显示 ============
+        function updateLivesDisplay() {
+            const hearts = '❤️'.repeat(playerLives) + '🖤'.repeat(3 - playerLives);
+            document.getElementById('lives-display').textContent = hearts;
+        }
+        // ============ 事件监听 ============
+        function setupEventListeners() {
+            window.addEventListener('keydown', (e) => {
+                if (keys.hasOwnProperty(e.code)) keys[e.code] = true;
+            });
+            window.addEventListener('keyup', (e) => {
+                if (keys.hasOwnProperty(e.code)) keys[e.code] = false;
+            });
+            // 鼠标点击(身临其境模式切换用)
+            renderer.domElement.addEventListener('click', () => {
+                // 聚焦以便接收键盘事件
+                renderer.domElement.focus();
+            });
+            // 视角切换
+            document.getElementById('btn-free').addEventListener('click', () => {
+                viewMode = 'free';
+                document.getElementById('btn-free').classList.add('active');
+                document.getElementById('btn-immersive').classList.remove('active');
+                orbitControls.enabled = true;
+                camera.position.set(0, 15, 15);
+                camera.lookAt(0, 0, 0);
+            });
+            document.getElementById('btn-immersive').addEventListener('click', () => {
+                viewMode = 'immersive';
+                document.getElementById('btn-immersive').classList.add('active');
+                document.getElementById('btn-free').classList.remove('active');
+                orbitControls.enabled = false;
+                // 立即将相机放到玩家位置
+                camera.position.copy(playerSphere.position);
+                camera.position.y = 0.8;
+                // 重置旋转角度,让相机朝向迷宫中心方向
+                cameraRotationY = Math.PI; // 朝向 -Z 方向(迷宫深处)
+                cameraRotationX = 0;
+                camera.rotation.set(0, 0, 0);
+                camera.rotateY(cameraRotationY);
+                camera.rotateX(cameraRotationX);
+            });
+            // 重新开始
+            document.getElementById('restart-btn').addEventListener('click', () => {
+                location.reload();
+            });
+            // 游戏结束重新开始
+            document.getElementById('restart-btn-gameover').addEventListener('click', () => {
+                location.reload();
+            });
+            // 窗口大小变化
+            window.addEventListener('resize', () => {
+                camera.aspect = window.innerWidth / window.innerHeight;
+                camera.updateProjectionMatrix();
+                renderer.setSize(window.innerWidth, window.innerHeight);
+            });
+        }
+        // ============ 动画循环 ============
+        function animate() {
+            requestAnimationFrame(animate);
+            if (!gameWon && !gameOver) {
+                // 方向键控制视角(身临其境模式)
+                if (viewMode === 'immersive') {
+                    if (keys.ArrowLeft) cameraRotationY += 0.06;
+                    if (keys.ArrowRight) cameraRotationY -= 0.06;
+                    if (keys.ArrowUp) cameraRotationX = Math.max(-Math.PI / 3, cameraRotationX - 0.04);
+                    if (keys.ArrowDown) cameraRotationX = Math.min(Math.PI / 3, cameraRotationX + 0.04);
+                }
+                let isMoving = false;
+                // 移动方向(WASD 控制)
+                // 先更新身临其境视角相机(这样移动才能用正确的朝向)
+                if (viewMode === 'immersive') {
+                    camera.position.copy(playerSphere.position);
+                    camera.position.y = 0.8;
+                    camera.rotation.set(0, 0, 0);
+                    camera.rotateY(cameraRotationY);
+                    camera.rotateX(cameraRotationX);
+                }
+                let moveDir = new THREE.Vector3();
+                if (keys.KeyW) moveDir.z -= 1;
+                if (keys.KeyS) moveDir.z += 1;
+                if (keys.KeyA) moveDir.x -= 1;
+                if (keys.KeyD) moveDir.x += 1;
+                if (moveDir.length() > 0) {
+                    isMoving = true;
+                    moveDir.normalize();
+                    // 根据视角方向计算移动方向
+                    moveDir.applyQuaternion(camera.quaternion);
+                    moveDir.y = 0;
+                    moveDir.normalize();
+                    const currentPos = playerSphere.position.clone();
+                    currentPos.y = 0;
+                    const maxDist = canMoveTo(currentPos, moveDir, MOVE_SPEED);
+                    if (maxDist > 0) {
+                        playerSphere.position.add(moveDir.multiplyScalar(maxDist));
+                    }
+                }
+                // 浮动效果
+                if (!isMoving) {
+                    playerSphere.position.y = PLAYER_RADIUS - 0.5 + Math.sin(Date.now() * 0.002) * 0.1;
+                } else {
+                    playerSphere.position.y = PLAYER_RADIUS - 0.5;
+                }
+                // 旗帜飘动
+                if (endFlag) {
+                    endFlag.children[1].rotation.y = Math.sin(Date.now() * 0.003) * 0.3 + Math.PI / 4;
+                }
+                // 僵尸追击玩家
+                if (zombie && !gameWon) {
+                    const toPlayer = new THREE.Vector3();
+                    toPlayer.subVectors(playerSphere.position, zombie.position);
+                    toPlayer.y = 0;
+                    const distToPlayer = toPlayer.length();
+                    if (distToPlayer > 1) {
+                        toPlayer.normalize();
+                        // 僵尸可以直接穿墙,但穿墙时速度会变慢
+                        const zombiePos = zombie.position.clone();
+                        zombiePos.y = 0;
+                        const moveResult = canZombieMove(zombiePos, toPlayer, MOVE_SPEED * 0.5);
+                        // 穿墙时颜色变深表示正在穿墙
+                        const bodyMesh = zombie.children[0];
+                        if (moveResult.inWall) {
+                            bodyMesh.material.color.setHex(0x4a0000); // 深红色,表示穿墙中
+                        } else {
+                            bodyMesh.material.color.setHex(0x8B0000); // 正常红色
+                        }
+                        if (moveResult.canMove) {
+                            zombie.position.add(toPlayer.clone().multiplyScalar(moveResult.distance));
+                        }
+                        // 让僵尸朝向玩家
+                        zombie.lookAt(playerSphere.position.x, zombie.position.y, playerSphere.position.z);
+                    }
+                    // 僵尸上下浮动
+                    zombie.position.y = 0.25 + Math.sin(Date.now() * 0.003) * 0.05;
+                    // ===== 恐怖特效 =====
+                    // 计算危险程度（基于距离）
+                    const dangerDistance = 8; // 开始显示警告的距离
+                    const dangerOpacity = Math.max(0, 1 - distToPlayer / dangerDistance);
+                    // 检测僵尸是否攻击到玩家
+                    const attackDist = distToPlayer < 1.2; // 攻击距离
+                    if (attackDist && !isInvincible && !gameOver) {
+                        playerLives--;
+                        updateLivesDisplay();
+                        if (playerLives <= 0) {
+                            gameOver = true;
+                            // 游戏结束 - 全屏血红特效
+                            document.getElementById('danger-overlay').style.background = 'radial-gradient(circle, rgba(139,0,0,0.9) 0%, rgba(50,0,0,0.95) 100%)';
+                            document.getElementById('danger-overlay').style.opacity = '1';
+                            document.getElementById('game-over-message').style.display = 'block';
+                        } else {
+                            // 攻击特效 - 闪红
+                            document.getElementById('danger-overlay').style.background = 'radial-gradient(circle, rgba(255,0,0,0.8) 0%, rgba(139,0,0,0.9) 100%)';
+                            document.getElementById('danger-overlay').style.opacity = '1';
+                            setTimeout(() => {
+                                document.getElementById('danger-overlay').style.opacity = (dangerOpacity * 0.5).toString();
+                                document.getElementById('danger-overlay').style.background = 'radial-gradient(circle, rgba(255,200,0,0.3) 0%, rgba(255,100,0,0) 100%)';
+                            }, 200);
+                            // 给玩家1秒无敌时间
+                            isInvincible = true;
+                            invincibilityTimer = 60; // 约1秒(60帧)
+                            // 闪烁玩家
+                            playerSphere.material.color.setHex(0xff6666);
+                        }
+                    }
+                    // 僵尸靠近时显示黄色警告（只有在攻击范围内且不是无敌时间）
+                    if (!isInvincible && !gameOver) {
+                        if (distToPlayer < dangerDistance && distToPlayer >= 1.2) {
+                            // 黄色危险光晕
+                            const yellowOpacity = dangerOpacity * 0.5;
+                            document.getElementById('danger-overlay').style.background = `radial-gradient(circle, rgba(255,200,0,${yellowOpacity * 0.3}) 0%, rgba(255,100,0,${yellowOpacity * 0.2}) 50%, transparent 70%)`;
+                            document.getElementById('danger-overlay').style.opacity = '1';
+                        } else if (distToPlayer >= dangerDistance) {
+                            // 远离后渐隐
+                            document.getElementById('danger-overlay').style.opacity = '0';
+                        }
+                    }
+                    // 无敌时间倒计时
+                    if (isInvincible) {
+                        invincibilityTimer--;
+                        // 闪烁效果
+                        playerSphere.visible = Math.floor(invincibilityTimer / 5) % 2 === 0;
+                        if (invincibilityTimer <= 0) {
+                            isInvincible = false;
+                            playerSphere.visible = true;
+                            playerSphere.material.color.setHex(0x4a90d9);
+                        }
+                    }
+                }
+                // 检测胜利
+                checkWin();
+            }
+            if (viewMode === 'free') {
+                orbitControls.update();
+            }
+            renderer.render(scene, camera);
+        }
+        // ============ 检测胜利 ============
+        function checkWin() {
+            const endX = (MAZE_SIZE - 2) * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+            const endZ = (MAZE_SIZE - 2) * CELL_SIZE - (MAZE_SIZE * CELL_SIZE) / 2 + CELL_SIZE / 2;
+            const dx = playerSphere.position.x - endX;
+            const dz = playerSphere.position.z - endZ;
+            const dist = Math.sqrt(dx * dx + dz * dz);
+            if (dist < 1.5) {
+                gameWon = true;
+                document.getElementById('win-message').style.display = 'block';
+            }
+        }
+        // ============ 启动 ============
+        init();
+        animate();
+    </script>
+</body>
+</html>