sa2kit 1.6.0 → 1.6.2

package/dist/mmd/index.d.ts

@@ -1,5 +1,5 @@
-import { e as MMDPlayerBaseProps, f as MMDPlayerBaseRef, g as MMDPlayerEnhancedProps, h as MMDPlaylistProps, b as MMDPlaylistNode, d as MMDResources, i as MMDStage, j as MobileOptimization } from '../types-CsTSddwu.js';
-export { M as MMDPlaylistConfig, a as MMDResourceItem, c as MMDResourceOptions, R as ResourceOption } from '../types-CsTSddwu.js';
+import { e as MMDPlayerBaseProps, f as MMDPlayerBaseRef, g as MMDPlayerEnhancedProps, h as MMDPlaylistProps, b as MMDPlaylistNode, d as MMDResources, i as MMDStage, j as MobileOptimization } from '../types-DxYJqqes.js';
+export { B as BloomOptions, M as MMDPlaylistConfig, a as MMDResourceItem, c as MMDResourceOptions, O as OutlineOptions, R as ResourceOption } from '../types-DxYJqqes.js';
 import React__default from 'react';
 import 'three';
 
@@ -87,17 +87,50 @@ interface DialogueLine {
     expression?: string;
     /** 对话时播放的音效（可选） */
     voicePath?: string;
+    /** 对话中插入的分支选项（可选，若有则显示选项） */
+    choices?: DialogueChoice[];
+    /** 视觉特效（可选） */
+    effect?: VisualEffect;
+}
+/** 视觉特效配置 */
+interface VisualEffect {
+    /** 特效类型 */
+    type: 'flash' | 'gif' | 'shake';
+    /** 闪屏颜色，如 'white', 'red' */
+    color?: string;
+    /** 持续时间（毫秒） */
+    duration?: number;
+    /** GIF 动画地址 */
+    url?: string;
+    /** GIF 显示位置 */
+    position?: 'center' | 'full';
+}
+/** 分支判定逻辑 */
+interface BranchCondition {
+    /** 变量名 */
+    key: string;
+    /** 变量值与节点索引的映射 */
+    map: Record<string | number, number>;
+    /** 默认跳转的节点索引 */
+    defaultIndex: number;
 }
 /** 对话分支选项 */
 interface DialogueChoice {
     /** 选项文字 */
     text: string;
-    /** 跳转到的节点索引 */
-    nextNodeIndex: number;
+    /** 跳转到的节点索引（可选，若不填则继续当前剧情） */
+    nextNodeIndex?: number;
     /** 跳转到的对话索引（可选，默认 0） */
     nextDialogueIndex?: number;
+    /** 设置变量（可选，用于后续剧情判定） */
+    setVariable?: {
+        key: string;
+        value: string | number | boolean;
+    };
     /** 选项点击后的回调（可选） */
     onSelect?: () => void;
+    /** 点击选项后触发的特效（可选） */
+    effect?: VisualEffect;
 }
 /** 视觉小说播放节点 */
 interface VisualNovelNode {
@@ -111,8 +144,10 @@ interface VisualNovelNode {
     dialogues: DialogueLine[];
     /** 节点特定的舞台配置（可选，覆盖全局配置） */
     stage?: MMDStage;
-    /** 节点结束时的分支选项（可选，若有则显示选项，不自动跳转） */
+    /** 节点结束时的分支选项（可选，已废弃，建议使用 DialogueLine.choices） */
     choices?: DialogueChoice[];
+    /** 节点结束时的分支判定逻辑（可选，根据变量跳转不同节点） */
+    nextCondition?: BranchCondition;
     /** 节点开始时播放的背景音乐（可选） */
     bgmPath?: string;
     /** 背景音乐音量 0-1（默认 0.5） */
@@ -240,6 +275,10 @@ interface MMDVisualNovelRef {
     getCurrentDialogueIndex: () => number;
     /** 获取对话历史 */
     getHistory: () => DialogueHistoryItem[];
+    /** 获取当前剧情变量 */
+    getVariables: () => Record<string, string | number | boolean>;
+    /** 设置剧情变量 */
+    setVariable: (key: string, value: string | number | boolean) => void;
     /** 设置自动播放模式 */
     setAutoMode: (enabled: boolean) => void;
     /** 跳过当前打字动画 */
@@ -344,6 +383,13 @@ interface StartScreenProps {
  */
 declare const StartScreen: React__default.FC<StartScreenProps>;
 
+interface ChoiceMenuProps {
+    choices: DialogueChoice[];
+    onSelect: (choice: DialogueChoice) => void;
+    theme?: DialogueBoxTheme;
+}
+declare const ChoiceMenu: React__default.FC<ChoiceMenuProps>;
+
 /** 音乐曲目配置 */
 interface MusicTrack {
     /** 唯一标识 */
@@ -459,4 +505,4 @@ interface TrackInfoProps {
 }
 declare const TrackInfo: React__default.FC<TrackInfoProps>;
 
-export { DialogueBox, type DialogueBoxProps, type DialogueBoxTheme, type DialogueChoice, type DialogueHistoryItem, type DialogueLine, HistoryPanel, LoadingOverlay, type LoadingOverlayProps, LoadingScreen, type LoadingScreenProps, MMDMusicPlayer, type MMDMusicPlayerConfig, type MMDMusicPlayerProps, type MMDMusicPlayerRef, MMDPlayerBase, MMDPlayerBaseProps, MMDPlayerBaseRef, MMDPlayerEnhanced, MMDPlayerEnhancedDebugInfo, MMDPlayerEnhancedProps, MMDPlaylist, MMDPlaylistDebugInfo, MMDPlaylistNode, MMDPlaylistProps, MMDResources, MMDStage, MMDVisualNovel, type MMDVisualNovelProps, type MMDVisualNovelRef, MobileOptimization, MusicControls, type MusicControlsProps, type MusicTrack, PlaylistPanel, type PlaylistPanelProps, StartScreen, type StartScreenProps, TrackInfo, type TrackInfoProps, type VisualNovelNode, type VisualNovelScript, loadAmmo };
+export { type BranchCondition, ChoiceMenu, type ChoiceMenuProps, DialogueBox, type DialogueBoxProps, type DialogueBoxTheme, type DialogueChoice, type DialogueHistoryItem, type DialogueLine, HistoryPanel, LoadingOverlay, type LoadingOverlayProps, LoadingScreen, type LoadingScreenProps, MMDMusicPlayer, type MMDMusicPlayerConfig, type MMDMusicPlayerProps, type MMDMusicPlayerRef, MMDPlayerBase, MMDPlayerBaseProps, MMDPlayerBaseRef, MMDPlayerEnhanced, MMDPlayerEnhancedDebugInfo, MMDPlayerEnhancedProps, MMDPlaylist, MMDPlaylistDebugInfo, MMDPlaylistNode, MMDPlaylistProps, MMDResources, MMDStage, MMDVisualNovel, type MMDVisualNovelProps, type MMDVisualNovelRef, MobileOptimization, MusicControls, type MusicControlsProps, type MusicTrack, PlaylistPanel, type PlaylistPanelProps, StartScreen, type StartScreenProps, TrackInfo, type TrackInfoProps, type VisualEffect, type VisualNovelNode, type VisualNovelScript, loadAmmo };

package/dist/mmd/index.js

@@ -163,8 +163,37 @@ async function waitForMaterialsReady(object, renderer, scene, camera) {
   for (let i = 0; i < 3; i++) {
     await new Promise((resolve) => {
       requestAnimationFrame(() => {
-        renderer.render(scene, camera);
-        console.log(`[MMDPlayerBase]   Warmup render ${i + 1}/3`);
+        try {
+          object.traverse((obj) => {
+            if (obj.isMesh) {
+              const mesh = obj;
+              const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+              const hasMorphAttributes = mesh.geometry.morphAttributes && Object.keys(mesh.geometry.morphAttributes).length > 0;
+              materials.forEach((m) => {
+                if (!hasMorphAttributes) {
+                  m.morphTargets = false;
+                  if (mesh.geometry.morphAttributes) {
+                    mesh.geometry.morphAttributes = {};
+                  }
+                  if (mesh.morphTargetInfluences) {
+                    mesh.morphTargetInfluences = [];
+                  }
+                  if (mesh.morphTargetDictionary) {
+                    mesh.morphTargetDictionary = {};
+                  }
+                  m.needsUpdate = true;
+                }
+              });
+              if (mesh.updateMorphTargets) {
+                mesh.updateMorphTargets();
+              }
+            }
+          });
+          renderer.render(scene, camera);
+          console.log(`[MMDPlayerBase]   Warmup render ${i + 1}/3`);
+        } catch (renderError) {
+          console.warn("[MMDPlayerBase] Warmup render failed (shader error?), skipping...", renderError);
+        }
         resolve();
       });
     });
@@ -192,10 +221,15 @@ var MMDPlayerBase = React6.forwardRef((props, ref) => {
     className,
     style
   } = props;
+  const renderEffect = props.renderEffect || stage.renderEffect || "default";
+  const outlineOptions = { ...stage.outlineOptions, ...props.outlineOptions };
+  const bloomOptions = { ...stage.bloomOptions, ...props.bloomOptions };
   const containerRef = React6.useRef(null);
   const sceneRef = React6.useRef(null);
   const cameraRef = React6.useRef(null);
   const rendererRef = React6.useRef(null);
+  const outlineEffectRef = React6.useRef(null);
+  const composerRef = React6.useRef(null);
   const controlsRef = React6.useRef(null);
   const helperRef = React6.useRef(null);
   const axesHelperRef = React6.useRef(null);
@@ -403,10 +437,28 @@ var MMDPlayerBase = React6.forwardRef((props, ref) => {
         }
         container.appendChild(renderer.domElement);
         rendererRef.current = renderer;
+        const effect = new threeStdlib.OutlineEffect(renderer, {
+          defaultThickness: outlineOptions.thickness ?? 3e-3,
+          defaultColor: new THREE__namespace.Color(outlineOptions.color ?? "#000000").toArray(),
+          defaultAlpha: 1,
+          defaultKeepAlive: true
+        });
+        outlineEffectRef.current = effect;
+        const composer = new threeStdlib.EffectComposer(renderer);
+        const renderPass = new threeStdlib.RenderPass(scene, camera);
+        composer.addPass(renderPass);
+        const bloomPass = new threeStdlib.UnrealBloomPass(
+          new THREE__namespace.Vector2(width, height),
+          bloomOptions.strength ?? 1,
+          bloomOptions.radius ?? 0.4,
+          bloomOptions.threshold ?? 0.8
+        );
+        composer.addPass(bloomPass);
+        composerRef.current = composer;
         const ambientLight = new THREE__namespace.AmbientLight(16777215, stage.ambientLightIntensity ?? 0.5);
         scene.add(ambientLight);
         const dirLight = new THREE__namespace.DirectionalLight(16777215, stage.directionalLightIntensity ?? 0.8);
-        dirLight.position.set(10, 20, 10);
+        dirLight.position.set(0, 10, 0);
         if (stage.enableShadow !== false) {
           dirLight.castShadow = true;
           dirLight.shadow.mapSize.width = mobileOptimization.enabled ? 1024 : 2048;
@@ -441,6 +493,9 @@ var MMDPlayerBase = React6.forwardRef((props, ref) => {
           cameraRef.current.aspect = w / h;
           cameraRef.current.updateProjectionMatrix();
           rendererRef.current.setSize(w, h);
+          if (composerRef.current) {
+            composerRef.current.setSize(w, h);
+          }
         };
         const resizeObserver = new ResizeObserver(onResize);
         resizeObserver.observe(container);
@@ -448,7 +503,11 @@ var MMDPlayerBase = React6.forwardRef((props, ref) => {
         onResize();
         console.log("[MMDPlayerBase] Starting render loop (animation paused)");
         animate();
-        console.log("[MMDPlayerBase] Start loading resources...", resources);
+        console.log("[MMDPlayerBase] Start loading resources...", {
+          model: resources.modelPath,
+          stage: resources.stageModelPath,
+          motion: resources.motionPath
+        });
         const loader = new threeStdlib.MMDLoader();
         const helper = new threeStdlib.MMDAnimationHelper({
           afterglow: 2
@@ -621,51 +680,67 @@ var MMDPlayerBase = React6.forwardRef((props, ref) => {
             (err) => console.error("Failed to load audio:", err)
           );
         }
-        let stageMesh = null;
-        if (resources.stageModelPath) {
+        const stagePaths = Array.isArray(resources.stageModelPath) ? resources.stageModelPath : resources.stageModelPath ? [resources.stageModelPath] : [];
+        for (const stagePath of stagePaths) {
           try {
-            stageMesh = await new Promise((resolve, reject) => {
+            console.log(`[MMDPlayerBase] Loading stage from: ${stagePath}`);
+            const stageMesh = await new Promise((resolve, reject) => {
               loader.load(
-                resources.stageModelPath,
+                stagePath,
                 (mesh2) => resolve(mesh2),
-                void 0,
+                (xhr) => {
+                  if (xhr.lengthComputable) {
+                    const percent = xhr.loaded / xhr.total * 100;
+                    if (Math.round(percent) % 20 === 0) console.log(`[MMDPlayerBase] Stage loading: ${percent.toFixed(1)}%`);
+                  }
+                },
                 (err) => reject(err)
               );
             });
             if (checkCancelled()) return;
-            console.log("[MMDPlayerBase] Stage model loaded:", stageMesh);
-            stageMesh.castShadow = true;
-            stageMesh.receiveShadow = true;
-            console.log("[MMDPlayerBase] Waiting for stage materials and textures...");
-            const tempStageScene = new THREE__namespace.Scene();
-            tempStageScene.add(stageMesh);
-            await waitForMaterialsReady(stageMesh, renderer, tempStageScene, camera);
-            tempStageScene.remove(stageMesh);
+            console.log(`[MMDPlayerBase] Stage model loaded: ${stagePath}`, stageMesh);
+            stageMesh.traverse((child) => {
+              if (child instanceof THREE__namespace.Mesh) {
+                child.castShadow = true;
+                child.receiveShadow = true;
+                const mesh2 = child;
+                const materials = Array.isArray(mesh2.material) ? mesh2.material : [mesh2.material];
+                materials.forEach((m, idx) => {
+                  if (m.morphTargets) {
+                    m.morphTargets = false;
+                    m.needsUpdate = true;
+                  }
+                });
+                if (mesh2.geometry.morphAttributes) {
+                  mesh2.geometry.morphAttributes = {};
+                }
+                if (mesh2.morphTargetInfluences) {
+                  mesh2.morphTargetInfluences = [];
+                }
+              }
+            });
+            try {
+              await waitForMaterialsReady(stageMesh, renderer, scene, camera);
+            } catch (e) {
+              console.warn(`[MMDPlayerBase] Warmup error for stage ${stagePath}:`, e);
+            }
             if (checkCancelled()) return;
-            console.log("[MMDPlayerBase] \u2705 Stage materials and textures loaded");
             scene.add(stageMesh);
-            console.log("[MMDPlayerBase] \u2705 Stage added to scene (fully loaded)");
-            if (resources.stageMotionPath && stageMesh) {
-              console.log("[MMDPlayerBase] Loading stage motion:", resources.stageMotionPath);
-              const anyLoader = loader;
-              const anyHelper = helper;
-              const anyStage = stageMesh;
-              anyLoader.loadAnimation(
-                resources.stageMotionPath,
-                anyStage,
-                (stageAnimation) => {
-                  if (checkCancelled()) return;
-                  anyHelper.add(anyStage, {
-                    animation: stageAnimation
-                  });
-                  console.log("[MMDPlayerBase] \u2705 Stage motion bound successfully");
-                },
-                void 0,
-                (err) => console.error("Failed to load stage motion:", err)
-              );
+            const stageBox = new THREE__namespace.Box3().setFromObject(stageMesh);
+            const stageSize = stageBox.getSize(new THREE__namespace.Vector3());
+            if (stageSize.length() < 1) {
+              stageMesh.scale.multiplyScalar(100);
+            } else if (stageSize.y < 5) {
+              stageMesh.scale.multiplyScalar(10);
+            }
+            console.log(`[MMDPlayerBase] \u2705 Stage added: ${stagePath}`);
+            if (resources.stageMotionPath) {
+              loader.loadAnimation(resources.stageMotionPath, stageMesh, (anim) => {
+                if (!checkCancelled()) helper.add(stageMesh, { animation: anim });
+              });
             }
           } catch (err) {
-            console.error("Failed to load stage:", err);
+            console.error(`Failed to load stage ${stagePath}:`, err);
           }
         }
         if (checkCancelled()) return;
@@ -1043,6 +1118,13 @@ ${errorMessage}
       }
       if (rendererRef.current) {
         try {
+          if (composerRef.current) {
+            composerRef.current.passes.forEach((pass) => {
+              if (pass.dispose) pass.dispose();
+            });
+            composerRef.current = null;
+          }
+          outlineEffectRef.current = null;
           const renderer = rendererRef.current;
           if (renderer.renderLists) {
             renderer.renderLists.dispose();
@@ -1109,6 +1191,17 @@ ${errorMessage}
       audioRef.current.setLoop(loop);
     }
   }, [loop]);
+  React6.useEffect(() => {
+    if (outlineEffectRef.current) ;
+    if (composerRef.current) {
+      const bloomPass = composerRef.current.passes.find((p) => p instanceof threeStdlib.UnrealBloomPass);
+      if (bloomPass) {
+        bloomPass.strength = bloomOptions.strength ?? 1;
+        bloomPass.radius = bloomOptions.radius ?? 0.4;
+        bloomPass.threshold = bloomOptions.threshold ?? 0.8;
+      }
+    }
+  }, [bloomOptions.strength, bloomOptions.radius, bloomOptions.threshold]);
   React6.useEffect(() => {
     if (!isReadyRef.current) return;
     if (sceneRef.current) {
@@ -1157,7 +1250,15 @@ ${errorMessage}
           latestCallbacks.current.onEnded?.();
         }
       }
-      rendererRef.current.render(sceneRef.current, cameraRef.current);
+      const useOutline = renderEffect === "outline" || renderEffect === "outline+bloom";
+      const useBloom = renderEffect === "bloom" || renderEffect === "outline+bloom";
+      if (useBloom && composerRef.current) {
+        composerRef.current.render();
+      } else if (useOutline && outlineEffectRef.current) {
+        outlineEffectRef.current.render(sceneRef.current, cameraRef.current);
+      } else {
+        rendererRef.current.render(sceneRef.current, cameraRef.current);
+      }
     }
   };
   return /* @__PURE__ */ React6__default.default.createElement(
@@ -2852,6 +2953,8 @@ var MMDVisualNovel = React6.forwardRef(
     const [pendingNodeIndex, setPendingNodeIndex] = React6.useState(null);
     const [showChoices, setShowChoices] = React6.useState(false);
     const [isCameraManual, setIsCameraManual] = React6.useState(false);
+    const [variables, setVariables] = React6.useState({});
+    const [activeEffect, setActiveEffect] = React6.useState(null);
     const playerRef = React6.useRef(null);
     const containerRef = React6.useRef(null);
     const autoTimerRef = React6.useRef(null);
@@ -2859,6 +2962,7 @@ var MMDVisualNovel = React6.forwardRef(
     const isStartedRef = React6.useRef(autoStart);
     const lastAnimationTimeRef = React6.useRef(0);
     const isVmdFinishedRef = React6.useRef(false);
+    const effectTimerRef = React6.useRef(null);
     const currentNode = nodes[currentNodeIndex];
     const currentDialogue = currentNode?.dialogues[currentDialogueIndex] || null;
     const addToHistory = React6.useCallback((dialogue, nodeIndex, dialogueIndex) => {
@@ -2873,32 +2977,17 @@ var MMDVisualNovel = React6.forwardRef(
         }
       ]);
     }, []);
-    const goToNextDialogue = React6.useCallback(() => {
-      if (!currentNode) return;
-      if (autoTimerRef.current) {
-        clearTimeout(autoTimerRef.current);
-        autoTimerRef.current = null;
+    const triggerEffect = React6.useCallback((effect) => {
+      if (!effect) return;
+      if (effectTimerRef.current) {
+        clearTimeout(effectTimerRef.current);
       }
-      const nextDialogueIndex = currentDialogueIndex + 1;
-      if (nextDialogueIndex < currentNode.dialogues.length && currentNode?.dialogues[nextDialogueIndex] !== void 0) {
-        const nextDialogue = currentNode.dialogues[nextDialogueIndex];
-        setCurrentDialogueIndex(nextDialogueIndex);
-        addToHistory(nextDialogue, currentNodeIndex, nextDialogueIndex);
-        onDialogueChange?.(nextDialogue, nextDialogueIndex, currentNodeIndex);
-        typingCompleteRef.current = false;
-      } else if (currentNode.choices && currentNode.choices.length > 0) {
-        setShowChoices(true);
-      } else {
-        const nextNodeIndex = currentNodeIndex + 1;
-        if (nextNodeIndex < nodes.length) {
-          goToNode(nextNodeIndex);
-        } else if (loop) {
-          goToNode(0);
-        } else {
-          onScriptComplete?.();
-        }
-      }
-    }, [currentNode, currentDialogueIndex, currentNodeIndex, nodes.length, loop, addToHistory, onDialogueChange, onScriptComplete]);
+      setActiveEffect(effect);
+      effectTimerRef.current = setTimeout(() => {
+        setActiveEffect(null);
+        effectTimerRef.current = null;
+      }, effect.duration || 1e3);
+    }, []);
     const goToNode = React6.useCallback(
       (nodeIndex, force = false) => {
         if (nodeIndex < 0 || nodeIndex >= nodes.length) return;
@@ -2937,8 +3026,52 @@ var MMDVisualNovel = React6.forwardRef(
           }, 100);
         }, 300);
       },
-      [nodes, isTransitioning, addToHistory, onNodeChange, onDialogueChange, currentNodeIndex, isVmdFinished]
+      [nodes, isTransitioning, addToHistory, onNodeChange, onDialogueChange, currentNodeIndex]
     );
+    const triggerNodeTransition = React6.useCallback(() => {
+      if (!currentNode) return;
+      let nextNodeIndex = currentNodeIndex + 1;
+      if (currentNode.nextCondition) {
+        const { key, map, defaultIndex } = currentNode.nextCondition;
+        const val = variables[key];
+        if (val !== void 0 && map[val] !== void 0) {
+          nextNodeIndex = map[val];
+          console.log(`[MMDVisualNovel] Branching: ${key}=${val} -> node ${nextNodeIndex}`);
+        } else {
+          nextNodeIndex = defaultIndex;
+        }
+      }
+      if (nextNodeIndex < nodes.length && nextNodeIndex >= 0) {
+        goToNode(nextNodeIndex);
+      } else if (loop) {
+        goToNode(0);
+      } else {
+        onScriptComplete?.();
+      }
+    }, [currentNode, currentNodeIndex, nodes.length, loop, variables, goToNode, onScriptComplete]);
+    const goToNextDialogue = React6.useCallback(() => {
+      if (!currentNode) return;
+      if (currentDialogue?.choices && currentDialogue.choices.length > 0 && !showChoices) {
+        setShowChoices(true);
+        return;
+      }
+      if (autoTimerRef.current) {
+        clearTimeout(autoTimerRef.current);
+        autoTimerRef.current = null;
+      }
+      const nextDialogueIndex = currentDialogueIndex + 1;
+      if (nextDialogueIndex < currentNode.dialogues.length && currentNode?.dialogues[nextDialogueIndex] !== void 0) {
+        const nextDialogue = currentNode.dialogues[nextDialogueIndex];
+        setCurrentDialogueIndex(nextDialogueIndex);
+        addToHistory(nextDialogue, currentNodeIndex, nextDialogueIndex);
+        onDialogueChange?.(nextDialogue, nextDialogueIndex, currentNodeIndex);
+        typingCompleteRef.current = false;
+      } else if (currentNode.choices && currentNode.choices.length > 0) {
+        setShowChoices(true);
+      } else {
+        triggerNodeTransition();
+      }
+    }, [currentNode, currentDialogue, currentDialogueIndex, currentNodeIndex, nodes.length, loop, addToHistory, onDialogueChange, onScriptComplete, showChoices, variables, goToNode, triggerNodeTransition]);
     const goToDialogue = React6.useCallback(
       (dialogueIndex) => {
         if (!currentNode) return;
@@ -2982,6 +3115,11 @@ var MMDVisualNovel = React6.forwardRef(
       }
       return void 0;
     }, [currentDialogue, handleTypingComplete]);
+    React6.useEffect(() => {
+      if (currentDialogue?.effect) {
+        triggerEffect(currentDialogue.effect);
+      }
+    }, [currentNodeIndex, currentDialogueIndex, triggerEffect]);
     const toggleAutoMode = React6.useCallback(() => {
       setIsAutoMode((prev) => !prev);
     }, []);
@@ -3017,12 +3155,17 @@ var MMDVisualNovel = React6.forwardRef(
         getCurrentNodeIndex: () => currentNodeIndex,
         getCurrentDialogueIndex: () => currentDialogueIndex,
         getHistory: () => history,
+        getVariables: () => variables,
+        setVariable: (key, value) => {
+          setVariables((prev) => ({ ...prev, [key]: value }));
+        },
         setAutoMode: setIsAutoMode,
         skipTyping: () => {
           typingCompleteRef.current = true;
-        }
+        },
+        triggerEffect
       }),
-      [goToNode, goToDialogue, currentNodeIndex, currentDialogueIndex, history]
+      [goToNode, goToDialogue, currentNodeIndex, currentDialogueIndex, history, triggerEffect]
     );
     React6.useEffect(() => {
       if (autoStart && currentNode && currentNode.dialogues.length > 0 && history.length === 0 && currentNode?.dialogues[0] !== void 0) {
@@ -3034,6 +3177,9 @@ var MMDVisualNovel = React6.forwardRef(
         if (autoTimerRef.current) {
           clearTimeout(autoTimerRef.current);
         }
+        if (effectTimerRef.current) {
+          clearTimeout(effectTimerRef.current);
+        }
       };
     }, []);
     if (!currentNode) {
@@ -3106,6 +3252,38 @@ var MMDVisualNovel = React6.forwardRef(
           }
         )
       ),
+      activeEffect && /* @__PURE__ */ React6__default.default.createElement(
+        "div",
+        {
+          className: "pointer-events-none absolute inset-0 flex items-center justify-center",
+          style: { zIndex: 999 }
+        },
+        activeEffect.type === "flash" && /* @__PURE__ */ React6__default.default.createElement(
+          "div",
+          {
+            className: "h-full w-full",
+            style: {
+              backgroundColor: activeEffect.color || "white",
+              animation: `flash-anim ${activeEffect.duration || 500}ms ease-out forwards`
+            }
+          }
+        ),
+        activeEffect.type === "gif" && activeEffect.url && /* @__PURE__ */ React6__default.default.createElement(
+          "img",
+          {
+            src: activeEffect.url,
+            alt: "effect",
+            className: activeEffect.position === "full" ? "h-full w-full object-cover" : "max-h-full max-w-full"
+          }
+        ),
+        /* @__PURE__ */ React6__default.default.createElement("style", null, `
+              @keyframes flash-anim {
+                0% { opacity: 0; }
+                25% { opacity: 1; }
+                100% { opacity: 0; }
+              }
+            `)
+      ),
       /* @__PURE__ */ React6__default.default.createElement(
         LoadingOverlay,
         {
@@ -3177,18 +3355,41 @@ var MMDVisualNovel = React6.forwardRef(
           }
         }
       ),
-      showChoices && currentNode.choices && /* @__PURE__ */ React6__default.default.createElement(
+      showChoices && (currentDialogue?.choices || currentNode.choices) && /* @__PURE__ */ React6__default.default.createElement(
         ChoiceMenu,
         {
-          choices: currentNode.choices,
+          choices: currentDialogue?.choices || currentNode.choices,
           theme: dialogueTheme,
           onSelect: (choice) => {
+            if (choice.setVariable) {
+              const { key, value } = choice.setVariable;
+              setVariables((prev) => ({ ...prev, [key]: value }));
+              console.log(`[MMDVisualNovel] Variable set: ${key} = ${value}`);
+            }
             choice.onSelect?.();
-            if (choice.nextNodeIndex === currentNodeIndex) {
-              goToDialogue(choice.nextDialogueIndex || 0);
-              setShowChoices(false);
-            } else {
-              goToNode(choice.nextNodeIndex, true);
+            if (choice.effect) {
+              triggerEffect(choice.effect);
+            }
+            setShowChoices(false);
+            if (choice.nextNodeIndex !== void 0) {
+              if (choice.nextNodeIndex === currentNodeIndex) {
+                goToDialogue(choice.nextDialogueIndex || 0);
+              } else {
+                goToNode(choice.nextNodeIndex, true);
+              }
+            } else if (currentDialogue?.choices) {
+              const nextIdx = currentDialogueIndex + 1;
+              if (currentNode && nextIdx < currentNode.dialogues.length) {
+                const nextDialogue = currentNode.dialogues[nextIdx];
+                if (nextDialogue) {
+                  setCurrentDialogueIndex(nextIdx);
+                  addToHistory(nextDialogue, currentNodeIndex, nextIdx);
+                  onDialogueChange?.(nextDialogue, nextIdx, currentNodeIndex);
+                  typingCompleteRef.current = false;
+                }
+              } else {
+                triggerNodeTransition();
+              }
             }
           }
         }
@@ -3607,6 +3808,7 @@ var MMDMusicPlayer = React6.forwardRef(
 );
 MMDMusicPlayer.displayName = "MMDMusicPlayer";
 
+exports.ChoiceMenu = ChoiceMenu;
 exports.DialogueBox = DialogueBox;
 exports.HistoryPanel = HistoryPanel;
 exports.LoadingOverlay = LoadingOverlay;