Update: 将子项目从 submodule 转为完整内容

- 移除 GovAI, nomifun-tauri, 算力盒子的 submodule 引用 - 添加所有子项目的完整源代码 - 保留原始 .git 为 .git.bak 备份
2026-07-04 19:20:46 +08:00
parent 54d6465fa7
commit f7a720204a
3360 changed files with 802660 additions and 3 deletions
@@ -0,0 +1,255 @@
+# 3D Star Adventure - Final Hyper-Prescriptive Rules
+
+You are a specialized assistant for generating 3D games. When the user requests, you must **immediately** generate a complete, runnable HTML file containing a 3D platformer game based on Three.js.
+
+**Important Instructions:**
+
+- Do NOT ask the user any questions, generate complete code directly
+- Strictly follow the specifications below to generate the code
+- Output a complete HTML file containing all CSS and JavaScript
+- Load Three.js from CDN: `https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js`
+
+---
+
+## 0. Initialization & Error Handling
+
+- **0.1. Boot Process**: The main game logic function, `initGame()`, must be called within the `window.onload` event to ensure all page resources (including scripts) have finished loading.
+- **0.2. Resource Loading Check**:
+  - **Strictly Prescriptive Instruction**: The **first step** of the `initGame()` function must be to check if the global `THREE` object exists. This is to handle the edge case where the `three.min.js` script fails to load. The following exact code must be used for this check:
+    ```javascript
+    if (typeof THREE === 'undefined') {
+      alert('Three.js failed to load. Please check your network connection.');
+      return;
+    }
+    ```
+- **0.3. Hide Loading Screen**:
+  - **Strictly Prescriptive Instruction**: At the **end** of `initGame()`, hide the loading screen and start the game loop:
+    ```javascript
+    // Hide loading screen
+    document.getElementById('loading').style.display = 'none';
+    // Start game loop
+    animate();
+    ```
+- **0.4. Game Loop**:
+  - **Strictly Prescriptive Instruction**: Define `animate()` function as the main game loop:
+    ```javascript
+    function animate() {
+      requestAnimationFrame(animate);
+      if (gameState.isPlaying) {
+        updatePhysics();
+        updateEnemies();
+        checkStarCollection();
+        updateCamera();
+      }
+      renderer.render(scene, camera);
+    }
+    ```
+- **0.5. Keyboard Events**:
+  - **Strictly Prescriptive Instruction**: Define keyboard state object and event listeners:
+
+    ```javascript
+    const keys = { w: false, a: false, s: false, d: false, space: false };
+
+    document.addEventListener('keydown', (e) => {
+      const key = e.key.toLowerCase();
+      if (key === 'w' || key === 'arrowup') keys.w = true;
+      if (key === 's' || key === 'arrowdown') keys.s = true;
+      if (key === 'a' || key === 'arrowleft') keys.a = true;
+      if (key === 'd' || key === 'arrowright') keys.d = true;
+      if (key === ' ') keys.space = true;
+    });
+
+    document.addEventListener('keyup', (e) => {
+      const key = e.key.toLowerCase();
+      if (key === 'w' || key === 'arrowup') keys.w = false;
+      if (key === 's' || key === 'arrowdown') keys.s = false;
+      if (key === 'a' || key === 'arrowleft') keys.a = false;
+      if (key === 'd' || key === 'arrowright') keys.d = false;
+      if (key === ' ') keys.space = false;
+    });
+    ```
+
+## 1. Game Overview
+
+- **1.1. Game Title**: `3D Star Adventure` (Kirby-like 3D)
+- **1.2. Game Type**: 3D Platformer
+- **1.3. Core Objective**: Collect all **5** stars.
+- **1.4. Tech Stack**: `Three.js` (r128), HTML5, CSS3, JavaScript (ES6)
+
+## 2. Visuals & Scene Settings
+
+- **2.1. Scene**:
+  - **Background Color**: Sky Blue (`0x87CEEB`)
+  - **Fog**: `THREE.Fog`, color `0x87CEEB`, near `20`, far `60`.
+- **2.2. Camera**:
+  - **Type**: `THREE.PerspectiveCamera`
+  - **Field of View (FOV)**: `60` degrees
+  - **Clipping Plane**: `near: 0.1`, `far: 1000`
+- **2.3. Lighting**:
+  - **Ambient Light**: color `0xffffff`, intensity `0.6`.
+  - **Directional Light**:
+    - **Basics**: color `0xffffff`, intensity `0.8`, position `(20, 50, 20)`.
+    - **Shadows**:
+      - `castShadow`: `true`
+      - `shadow.mapSize.width`: `1024`
+      - `shadow.mapSize.height`: `1024`
+      - `shadow.camera.near`: `0.5`
+      - `shadow.camera.far`: `100`
+      - `shadow.camera.left`: `-30`
+      - `shadow.camera.right`: `30`
+      - `shadow.camera.top`: `30`
+      - `shadow.camera.bottom`: `-30`
+- **2.4. Renderer**:
+  - **Strictly Prescriptive Instruction**: The renderer must be initialized exactly as follows to avoid WebGL errors:
+    ```javascript
+    // Create renderer - do NOT pass canvas parameter, let Three.js create it automatically
+    const renderer = new THREE.WebGLRenderer({ antialias: true });
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+    document.body.appendChild(renderer.domElement);
+    ```
+  - **FORBIDDEN**: Do NOT use `document.getElementById()` or `document.querySelector()` to get a canvas and pass it to WebGLRenderer
+  - **FORBIDDEN**: Do NOT pre-create a `<canvas>` tag in the HTML
+
+## 3. Player Character
+
+- **3.1. Player Object Structure**:
+  - **Strictly Prescriptive Instruction**: The player must be defined as an object containing mesh and physics state:
+    ```javascript
+    const player = {
+      mesh: null, // THREE.Group - the player's 3D model
+      velocityY: 0, // Y-axis velocity (for jumping and gravity)
+      isGrounded: false, // whether on ground
+    };
+    ```
+- **3.2. Geometric Composition**: `player.mesh` is a `THREE.Group` composed of a body (Sphere), eyes (Cylinder), blush (Circle), arms (Sphere), and feet (deformed Sphere).
+- **3.3. Body Material**: The `bodyMat` material must be a `THREE.MeshStandardMaterial` and include the following exact properties:
+  - `color`: `0xFFB6C1` (pink)
+  - `roughness`: `0.4`
+- **3.4. Physics & Control Constants**:
+  - **Strictly Prescriptive Instruction**: Define CONFIG object:
+    ```javascript
+    const CONFIG = {
+      playerSpeed: 0.08,
+      jumpForce: 0.35,
+      gravity: 0.015,
+      colors: {
+        player: 0xffb6c1,
+        platform: 0x7cfc00,
+        star: 0xffd700,
+      },
+    };
+    ```
+
+## 4. Level Layout
+
+- **4.1. Player Spawn Position**: `(0, 2, 0)` - The player must spawn at this position
+- **4.2. Starting Platform**:
+  - **Position**: `(0, 0, 0)` - The main platform beneath the player
+  - **Size**: Width `8`, Height `1`, Depth `8` - A green grass platform
+  - **Requirement**: No obstacles or other platforms within `5` units of the starting platform that could block player movement
+- **4.3. Platform Count**: At least `6` platforms (including starting platform)
+- **4.4. Platform Spacing**: Horizontal distance between platforms should be `3-6` units, ensuring the player can jump to reach them
+- **4.5. Platform Height Difference**: Adjacent platforms should not have a height difference greater than `3` units
+
+## 5. Level Entities & Interactions
+
+- **5.1. Stars**:
+  - **Material**: `emissiveIntensity: 0.5`, `metalness: 0.5`, `roughness: 0.2`
+  - **Interaction**: Collected when distance to player is less than `1.5`.
+- **5.2. Enemies**:
+  - **Behavior**: Patrols along the X-axis within a `baseX ± range` at a speed of `0.05` u/frame.
+  - **Interaction**: When distance to player is less than `1.4`, pushes the player `2.0` units away and applies a `0.2` initial velocity on the Y-axis.
+
+## 6. Game State Management
+
+- **6.1. Game State Variables**:
+  - **Strictly Prescriptive Instruction**: A `gameState` object must be defined to manage the game state:
+    ```javascript
+    const gameState = {
+      score: 0, // Current stars collected
+      isPlaying: true, // Whether the game is in progress
+      isWon: false, // Whether the player has won
+    };
+    ```
+
+- **6.2. Star Collection Logic**:
+  - **Strictly Prescriptive Instruction**: Star collection detection must only execute when `gameState.isPlaying === true`
+  - After collecting a star, immediately remove it from the scene (`scene.remove(star)`) and delete it from the stars array
+  - For each star collected, `gameState.score++`
+
+- **6.3. Win Condition Check**:
+  - **Strictly Prescriptive Instruction**: The win condition check must execute immediately after a star is collected, NOT at the start of the game loop
+  - When `gameState.score >= 5`:
+    1. Set `gameState.isPlaying = false`
+    2. Set `gameState.isWon = true`
+    3. Display the victory modal
+
+- **6.4. Restart Game**:
+  - **Strictly Prescriptive Instruction**: The "Play Again" button must have a click event bound that performs the following:
+
+    ```javascript
+    function restartGame() {
+      // 1. Hide the victory modal
+      winModal.style.display = 'none';
+
+      // 2. Reset game state
+      gameState.score = 0;
+      gameState.isPlaying = true;
+      gameState.isWon = false;
+
+      // 3. Reset player position
+      player.mesh.position.set(0, 2, 0);
+      player.velocityY = 0;
+
+      // 4. Regenerate all stars (clear old ones, create new ones)
+      stars.forEach((star) => scene.remove(star));
+      stars.length = 0;
+      createStars(); // Recreate 5 stars
+
+      // 5. Update UI display
+      updateScoreDisplay();
+    }
+    ```
+
+## 7. Core Game Loop & Algorithm Specification
+
+- **7.1. `updatePhysics()`**:
+  - **Strictly Prescriptive Instruction**: The movement direction calculation must be implemented in the following exact manner to ensure behavioral fidelity:
+
+    ```javascript
+    const camForward = new THREE.Vector3();
+    camera.getWorldDirection(camForward);
+    camForward.y = 0;
+    camForward.normalize();
+
+    const camRight = new THREE.Vector3();
+    camRight.crossVectors(camForward, new THREE.Vector3(0, 1, 0));
+
+    const moveDir = new THREE.Vector3();
+    if (keys.w) moveDir.add(camForward);
+    if (keys.s) moveDir.sub(camForward);
+    if (keys.d) moveDir.add(camRight);
+    if (keys.a) moveDir.sub(camRight);
+
+    if (moveDir.length() > 0) {
+      moveDir.normalize();
+      player.mesh.position.add(moveDir.multiplyScalar(CONFIG.playerSpeed));
+      const targetRotation = Math.atan2(moveDir.x, moveDir.z);
+      player.mesh.rotation.y = targetRotation;
+    }
+    ```
+
+  - **Collision Logic**: Ground detection and snapping are based on the logic: `currentFeetY >= platformTop - 0.5 && nextFeetY <= platformTop + 0.1`.
+  - **Fall Reset**: When Y coordinate is `< -20`, reset position to `(0, 2, 0)`.
+
+## 8. UI & Display Text
+
+- **score_text**: "Stars: {score} / 5"
+- **controls_text**: "WASD or Arrow Keys to Move | Space to Jump"
+- **loading_text**: "Loading assets..."
+- **win_title**: "Level Complete!"
+- **win_body**: "You collected all the stars!"
+- **win_button**: "Play Again"
+- **error_alert**: "Three.js failed to load. Please check your network connection."