@luna-editor/engine 0.2.0 → 0.3.0

package/dist/types.d.ts

@@ -1,4 +1,7 @@
-export type ScenarioBlockType = "dialogue" | "narration" | "action_node" | "character_entrance" | "character_exit";
+export type SoundCategory = "bgm" | "se" | "voice";
+/** Block options stored as key-value pairs */
+export type BlockOptions = Record<string, string | number | boolean>;
+export type ScenarioBlockType = "dialogue" | "narration" | "action_node" | "character_entrance" | "character_state_change" | "bgm_play" | "se_play" | "bgm_stop" | "conversation_branch" | "background_change" | "background_group" | "variable_operation" | "fullscreen_text" | "click_wait" | "time_wait";
 export interface ScenarioBlock {
     id: string;
     scenarioId: string;
@@ -9,9 +12,10 @@ export interface ScenarioBlock {
     speakerStateId: string | null;
     partVoiceId: string | null;
     actionNodeId: string | null;
-    linkedExitBlockId: string | null;
     createdAt: Date;
     updatedAt: Date;
+    /** Plugin-defined block options (key-value pairs) */
+    options?: BlockOptions | null;
     speaker?: {
         id: string;
         name: string;
@@ -28,15 +32,64 @@ export interface ScenarioBlock {
         scale?: number;
         translateY?: number;
         translateX?: number;
+        isDefault?: boolean;
+        layers?: EntityStateLayer[];
     } | null;
     actionNode?: ActionNode | null;
     attributeValues: ScenarioBlockAttributeValue[];
     entityAttributeValues: ScenarioBlockEntityAttributeValue[];
     characters?: ScenarioBlockCharacter[];
-    linkedExitBlock?: {
+    soundId?: string | null;
+    sound?: {
         id: string;
-        order: number;
+        name: string;
+        url: string;
+        duration: number | null;
+        loop: boolean;
+        soundType: {
+            id: string;
+            name: string;
+            category: SoundCategory;
+        };
+    } | null;
+    backgroundObjectId?: string | null;
+    backgroundStateId?: string | null;
+    backgroundObjectFit?: "contain" | "cover" | null;
+    backgroundLoop?: boolean | null;
+    backgroundObject?: {
+        id: string;
+        name: string;
     } | null;
+    backgroundState?: {
+        id: string;
+        name: string;
+        imageUrl: string | null;
+        webmUrl?: string | null;
+    } | null;
+    backgroundGroupItems?: BackgroundGroupItem[];
+}
+/** 背景の表示レイヤー（BackgroundGroupItem用） */
+type BackgroundGroupLayerType = "background" | "above_character" | "above_dialogue" | "above_all_ui";
+export interface BackgroundGroupItem {
+    id: string;
+    scenarioBlockId: string;
+    objectId: string;
+    stateId: string;
+    objectFit: "contain" | "cover";
+    loop: boolean;
+    opacity: number;
+    order: number;
+    layer: BackgroundGroupLayerType;
+    object: {
+        id: string;
+        name: string;
+    };
+    state: {
+        id: string;
+        name: string;
+        imageUrl: string | null;
+        webmUrl?: string | null;
+    };
 }
 export interface ScenarioBlockCharacter {
     id: string;
@@ -50,6 +103,7 @@ export interface ScenarioBlockCharacter {
     object: {
         id: string;
         name: string;
+        isLayerEnabled?: boolean;
     };
     entityState: {
         id: string;
@@ -59,7 +113,18 @@ export interface ScenarioBlockCharacter {
         scale?: number;
         translateY?: number;
         translateX?: number;
+        isDefault?: boolean;
+        layers?: EntityStateLayer[];
     };
+    baseBodyState?: {
+        id: string;
+        objectId: string;
+        name: string;
+        imageUrl: string | null;
+        scale?: number;
+        translateY?: number;
+        translateX?: number;
+    } | null;
 }
 export interface ActionNode {
     id: string;
@@ -115,10 +180,18 @@ export interface Character {
     state?: EntityState;
     element?: HTMLElement;
 }
+export interface EntityStateLayer {
+    id: string;
+    entityStateId: string;
+    imageUrl: string;
+    sortOrder: number;
+}
 export interface EntityState {
     id: string;
     name: string;
     imageUrl?: string | null;
+    isDefault?: boolean;
+    layers?: EntityStateLayer[];
 }
 export interface DisplayedCharacter {
     objectId: string;
@@ -130,6 +203,7 @@ export interface DisplayedCharacter {
     object: {
         id: string;
         name: string;
+        isLayerEnabled?: boolean;
     };
     entityState: {
         id: string;
@@ -139,7 +213,69 @@ export interface DisplayedCharacter {
         scale?: number;
         translateY?: number;
         translateX?: number;
+        isDefault?: boolean;
+        layers?: EntityStateLayer[];
     };
+    baseBodyState?: {
+        id: string;
+        name: string;
+        imageUrl: string | null;
+        scale?: number;
+        translateY?: number;
+        translateX?: number;
+    } | null;
+}
+export type VariableType = "string" | "number" | "choice" | "boolean";
+export type VariableOperationType = "set" | "add" | "subtract" | "toggle";
+export type VariableConditionType = "equals" | "less_than" | "greater_than";
+export type BranchType = "choice" | "variable";
+export interface Variable {
+    id: string;
+    workId: string;
+    name: string;
+    type: VariableType;
+    defaultValueString: string | null;
+    defaultValueNumber: number | null;
+    defaultValueChoice: string | null;
+    defaultValueBoolean: boolean | null;
+    choices?: VariableChoice[];
+}
+export interface VariableChoice {
+    id: string;
+    variableId: string;
+    label: string;
+    order: number;
+}
+export interface VariableOperation {
+    id: string;
+    blockId: string;
+    variableId: string;
+    operationType: VariableOperationType;
+    valueString: string | null;
+    valueNumber: number | null;
+    valueChoice: string | null;
+    valueBoolean: boolean | null;
+    variable?: Variable;
+}
+export interface VariableBranchCondition {
+    id: string;
+    branchId: string;
+    choiceId: string;
+    variableId: string;
+    conditionType: VariableConditionType;
+    valueString: string | null;
+    valueNumber: number | null;
+    valueChoice: string | null;
+    valueBoolean: boolean | null;
+    order: number;
+}
+export type FontType = "google" | "custom";
+export interface WorkFont {
+    id: string;
+    name: string;
+    fontFamily: string;
+    type: FontType;
+    url: string | null;
 }
 export interface PublishedScenario {
     id: string;
@@ -149,6 +285,10 @@ export interface PublishedScenario {
     description: string | null;
     blocks: ScenarioBlock[];
     publishedAt: Date;
+    variables?: Variable[];
+    variableOperations?: VariableOperation[];
+    variableBranchConditions?: VariableBranchCondition[];
+    fonts?: WorkFont[];
 }
 export interface PlayerSettings {
     aspectRatio: string;
@@ -167,16 +307,30 @@ export interface PlayerSettings {
     effectVolume?: number;
     /** テキスト音音量 (0-1, デフォルト: 1) */
     textSoundVolume?: number;
+    /** デフォルト背景フェード時間 (ミリ秒, デフォルト: 0) */
+    defaultBackgroundFadeDuration?: number;
+    /** 全ての音声をミュートする (デフォルト: false) */
+    muteAudio?: boolean;
+    /** 選択されたフォントファミリー */
+    selectedFontFamily?: string;
 }
 export interface PluginConfig {
     packageName: string;
     bundleUrl: string;
     config?: unknown;
 }
+/** 作品のサウンドデータ（プラグインからアクセス可能） */
+export interface WorkSound {
+    id: string;
+    name: string;
+    url: string;
+}
 export interface PlayerProps {
     scenario: PublishedScenario;
     settings?: PlayerSettings;
     plugins?: PluginConfig[];
+    /** 作品のサウンドデータ（プラグインからplayWorkSoundで使用可能） */
+    sounds?: WorkSound[];
     onEnd?: () => void;
     onScenarioEnd?: () => void;
     onScenarioStart?: () => void;
@@ -184,11 +338,22 @@ export interface PlayerProps {
     onSettingsChange?: (settings: PlayerSettings) => void;
     className?: string;
     autoplay?: boolean;
+    /** ホイールスクロールを無効化するかどうか（デフォルト: true） */
+    preventDefaultScroll?: boolean;
+    /** 画面サイズを明示的に指定（プレビュー用）。指定しない場合はwindowサイズを使用 */
+    screenSize?: {
+        width: number;
+        height: number;
+    };
+    /** キーボードナビゲーションを無効化するかどうか（デフォルト: false） */
+    disableKeyboardNavigation?: boolean;
 }
+export type VariableValue = string | number | boolean;
 export interface PlayerState {
     currentBlockIndex: number;
     isPlaying: boolean;
     isEnded: boolean;
+    variables?: Map<string, VariableValue>;
 }
 export interface BacklogEntry {
     id: string;
@@ -198,4 +363,123 @@ export interface BacklogEntry {
     content: string | null;
     speakerName?: string;
     speakerState?: string;
+    /** Block options (for plugin-defined options like bubble style) */
+    options?: BlockOptions | null;
+}
+export interface ConversationBranch {
+    id: string;
+    blockId: string;
+    workId: string;
+    branchType?: BranchType;
+    createdAt: Date;
+    updatedAt: Date;
+    branchChoices: ConversationChoice[];
+}
+export interface ConversationChoice {
+    id: string;
+    branchId: string;
+    choiceText: string;
+    order: number;
+    createdAt: Date;
+    updatedAt: Date;
+    branchBlocks: ConversationBranchBlock[];
+}
+export interface ConversationBranchBlock {
+    id: string;
+    choiceId: string;
+    blockType: ScenarioBlockType;
+    content: string | null;
+    speakerId: string | null;
+    speakerStateId: string | null;
+    actionNodeId: string | null;
+    partVoiceId: string | null;
+    order: number;
+    createdAt: Date;
+    updatedAt: Date;
+    speaker?: {
+        id: string;
+        name: string;
+        typeId: string;
+        workId: string;
+        description: string | null;
+        order: number;
+    } | null;
+    speakerState?: {
+        id: string;
+        name: string;
+        imageUrl: string | null;
+        cropArea: string | null;
+        scale?: number;
+        translateY?: number;
+        translateX?: number;
+    } | null;
+    actionNode?: ActionNode | null;
+    backgroundObjectId?: string | null;
+    backgroundStateId?: string | null;
+    backgroundObjectFit?: "contain" | "cover" | null;
+    backgroundLoop?: boolean | null;
+    backgroundObject?: {
+        id: string;
+        name: string;
+    } | null;
+    backgroundState?: {
+        id: string;
+        name: string;
+        imageUrl: string | null;
+        webmUrl?: string | null;
+    } | null;
+}
+export interface ChoiceData {
+    id: string;
+    text: string;
+    order: number;
+    isDisabled?: boolean;
+}
+export type ConversationBranchError = "DATA_MISSING" | "NETWORK_ERROR" | "INVALID_STRUCTURE" | "NO_MATCHING_CONDITION";
+export interface ConversationBranchState {
+    isActive: boolean;
+    branchType?: BranchType;
+    currentChoices: ChoiceData[];
+    selectedChoiceId: string | null;
+    errorState: ConversationBranchError | null;
+}
+export interface BranchChoiceHistory {
+    branchBlockId: string;
+    selectedChoiceId: string;
+    branchBlockIndex?: number;
+}
+export type ConversationBranchEvent = "START" | "CHOICE_AVAILABLE" | "CHOICE_SELECTED" | "END" | "ERROR";
+export interface BranchEventCallback {
+    onChoiceSelected?: (choiceId: string) => void;
+    onBranchStarted?: (choices: ChoiceData[]) => void;
+    onBranchEnded?: () => void;
+    onError?: (error: ConversationBranchError) => void;
+}
+export interface EnhancedPlayerState extends PlayerState {
+    branchHistory: BranchChoiceHistory[];
+    isInBranch: boolean;
+    currentBranchState?: ConversationBranchState;
+}
+export type BackgroundMediaType = "image" | "gif" | "video";
+/** 背景の表示レイヤー */
+export type BackgroundLayerType = "background" | "above_character" | "above_dialogue" | "above_all_ui";
+export interface BackgroundData {
+    objectId: string;
+    stateId: string;
+    objectName: string;
+    stateName: string;
+    imageUrl: string;
+    /** WebM形式のURL（iOS/macOS以外で使用） */
+    webmUrl?: string | null;
+    objectFit: "contain" | "cover";
+    loop: boolean;
+    mediaType: BackgroundMediaType;
+    /** フェード時間（ミリ秒） */
+    fadeDuration?: number;
+    /** 不透明度 (0.0-1.0, default 1.0) */
+    opacity?: number;
+    /** 表示レイヤー (default: "background") */
+    layer?: BackgroundLayerType;
 }
+export type BackgroundGroupData = BackgroundData[];
+export {};

package/dist/utils/branchBlockConverter.d.ts

@@ -0,0 +1,2 @@
+import type { ConversationBranchBlock, ScenarioBlock } from "../types";
+export declare function convertBranchBlockToScenarioBlock(branchBlock: ConversationBranchBlock): ScenarioBlock;

package/dist/utils/branchBlockConverter.js

@@ -0,0 +1,21 @@
+export function convertBranchBlockToScenarioBlock(branchBlock) {
+    return {
+        id: branchBlock.id,
+        scenarioId: "",
+        order: branchBlock.order,
+        blockType: branchBlock.blockType,
+        content: branchBlock.content,
+        speakerId: branchBlock.speakerId,
+        speakerStateId: branchBlock.speakerStateId,
+        partVoiceId: branchBlock.partVoiceId,
+        actionNodeId: branchBlock.actionNodeId,
+        createdAt: branchBlock.createdAt,
+        updatedAt: branchBlock.updatedAt,
+        speaker: branchBlock.speaker,
+        speakerState: branchBlock.speakerState,
+        actionNode: branchBlock.actionNode,
+        attributeValues: [],
+        entityAttributeValues: [],
+        characters: [],
+    };
+}

package/dist/utils/branchNavigator.d.ts

@@ -0,0 +1,14 @@
+import type { ConversationBranchBlock, ConversationChoice } from "../types";
+export declare class BranchNavigator {
+    private branchBlocks;
+    private currentIndex;
+    private isActive;
+    startBranchNavigation(choice: ConversationChoice, startIndex?: number): void;
+    nextBranchBlock(): ConversationBranchBlock | null;
+    getCurrentBranchBlock(): ConversationBranchBlock | null;
+    getCurrentBranchBlockIndex(): number;
+    previousBranchBlock(): ConversationBranchBlock | null;
+    hasMoreBranchBlocks(): boolean;
+    reset(): void;
+    getIsActive(): boolean;
+}

package/dist/utils/branchNavigator.js

@@ -0,0 +1,55 @@
+export class BranchNavigator {
+    constructor() {
+        this.branchBlocks = [];
+        this.currentIndex = 0;
+        this.isActive = false;
+    }
+    startBranchNavigation(choice, startIndex = 0) {
+        this.branchBlocks = [...choice.branchBlocks].sort((a, b) => a.order - b.order);
+        this.currentIndex = startIndex;
+        this.isActive = this.branchBlocks.length > 0;
+        if (this.currentIndex >= this.branchBlocks.length) {
+            this.currentIndex = 0;
+            this.isActive = false;
+        }
+    }
+    nextBranchBlock() {
+        if (!this.isActive || this.currentIndex >= this.branchBlocks.length) {
+            return null;
+        }
+        const block = this.branchBlocks[this.currentIndex];
+        this.currentIndex++;
+        if (this.currentIndex >= this.branchBlocks.length) {
+            this.isActive = false;
+        }
+        return block;
+    }
+    getCurrentBranchBlock() {
+        if (!this.isActive || this.currentIndex >= this.branchBlocks.length) {
+            return null;
+        }
+        return this.branchBlocks[this.currentIndex];
+    }
+    getCurrentBranchBlockIndex() {
+        return this.currentIndex;
+    }
+    previousBranchBlock() {
+        if (this.currentIndex > 0) {
+            this.currentIndex--;
+            this.isActive = true;
+            return this.branchBlocks[this.currentIndex];
+        }
+        return null;
+    }
+    hasMoreBranchBlocks() {
+        return this.isActive && this.currentIndex < this.branchBlocks.length;
+    }
+    reset() {
+        this.branchBlocks = [];
+        this.currentIndex = 0;
+        this.isActive = false;
+    }
+    getIsActive() {
+        return this.isActive;
+    }
+}

package/dist/utils/facePositionCalculator.js

@@ -115,7 +115,6 @@ export function calculateEffectPosition(facePosition, relativePosition, offsetX
         case "chin":
             baseY = facePosition.y + facePosition.height * 0.3;
             break;
-        case "center":
         default:
             // Use face center as is
             break;

package/dist/utils/variableManager.d.ts

@@ -0,0 +1,18 @@
+import type { Variable, VariableBranchCondition, VariableOperation, VariableValue } from "../types";
+export declare class VariableManager {
+    private variables;
+    private variableDefinitions;
+    private variableNameToId;
+    constructor(variables: Variable[]);
+    private getDefaultValue;
+    getValue(variableId: string): VariableValue | undefined;
+    getValueByName(variableName: string): VariableValue | undefined;
+    getVariableDefinition(variableId: string): Variable | undefined;
+    executeOperation(operation: VariableOperation): void;
+    private setValue;
+    evaluateCondition(condition: VariableBranchCondition): boolean;
+    private evaluateEquals;
+    interpolateText(text: string): string;
+    getVariablesMap(): Map<string, VariableValue>;
+    reset(): void;
+}

package/dist/utils/variableManager.js

@@ -0,0 +1,159 @@
+export class VariableManager {
+    constructor(variables) {
+        this.variables = new Map();
+        this.variableDefinitions = new Map();
+        this.variableNameToId = new Map();
+        for (const variable of variables) {
+            this.variableDefinitions.set(variable.id, variable);
+            this.variableNameToId.set(variable.name, variable.id);
+            this.variables.set(variable.id, this.getDefaultValue(variable));
+        }
+    }
+    getDefaultValue(variable) {
+        switch (variable.type) {
+            case "string":
+                return variable.defaultValueString || "";
+            case "number":
+                return variable.defaultValueNumber || 0;
+            case "boolean":
+                return variable.defaultValueBoolean || false;
+            case "choice":
+                return variable.defaultValueChoice || "";
+            default:
+                return "";
+        }
+    }
+    getValue(variableId) {
+        return this.variables.get(variableId);
+    }
+    getValueByName(variableName) {
+        const variableId = this.variableNameToId.get(variableName);
+        if (!variableId)
+            return undefined;
+        return this.variables.get(variableId);
+    }
+    getVariableDefinition(variableId) {
+        return this.variableDefinitions.get(variableId);
+    }
+    executeOperation(operation) {
+        const variable = this.variableDefinitions.get(operation.variableId);
+        if (!variable) {
+            console.warn(`Variable not found: ${operation.variableId}`);
+            return;
+        }
+        const currentValue = this.variables.get(operation.variableId);
+        switch (operation.operationType) {
+            case "set":
+                this.setValue(operation.variableId, variable, operation);
+                break;
+            case "add":
+                if (variable.type === "number" && typeof currentValue === "number") {
+                    const addValue = operation.valueNumber || 0;
+                    const newValue = Math.max(-1000000, Math.min(1000000, currentValue + addValue));
+                    this.variables.set(operation.variableId, newValue);
+                }
+                break;
+            case "subtract":
+                if (variable.type === "number" && typeof currentValue === "number") {
+                    const subtractValue = operation.valueNumber || 0;
+                    const newValue = Math.max(-1000000, Math.min(1000000, currentValue - subtractValue));
+                    this.variables.set(operation.variableId, newValue);
+                }
+                break;
+            case "toggle":
+                if (variable.type === "boolean" && typeof currentValue === "boolean") {
+                    this.variables.set(operation.variableId, !currentValue);
+                }
+                break;
+        }
+    }
+    setValue(variableId, variable, operation) {
+        switch (variable.type) {
+            case "string":
+                this.variables.set(variableId, operation.valueString || "");
+                break;
+            case "number":
+                this.variables.set(variableId, operation.valueNumber || 0);
+                break;
+            case "boolean":
+                this.variables.set(variableId, operation.valueBoolean || false);
+                break;
+            case "choice":
+                this.variables.set(variableId, operation.valueChoice || "");
+                break;
+        }
+    }
+    evaluateCondition(condition) {
+        const variable = this.variableDefinitions.get(condition.variableId);
+        if (!variable) {
+            console.warn(`Variable not found: ${condition.variableId}`);
+            return false;
+        }
+        const currentValue = this.variables.get(condition.variableId);
+        switch (condition.conditionType) {
+            case "equals":
+                return this.evaluateEquals(variable, currentValue, condition);
+            case "less_than":
+                if (variable.type === "number" &&
+                    typeof currentValue === "number" &&
+                    condition.valueNumber !== null) {
+                    return currentValue < condition.valueNumber;
+                }
+                return false;
+            case "greater_than":
+                if (variable.type === "number" &&
+                    typeof currentValue === "number" &&
+                    condition.valueNumber !== null) {
+                    return currentValue > condition.valueNumber;
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    evaluateEquals(variable, currentValue, condition) {
+        switch (variable.type) {
+            case "string":
+                return currentValue === (condition.valueString || "");
+            case "number":
+                return currentValue === (condition.valueNumber || 0);
+            case "boolean":
+                return currentValue === (condition.valueBoolean || false);
+            case "choice":
+                return currentValue === (condition.valueChoice || "");
+            default:
+                return false;
+        }
+    }
+    interpolateText(text) {
+        return text.replace(/\{([^}]+)\}/g, (match, variableName) => {
+            var _a;
+            const trimmedName = variableName.trim();
+            const variableId = this.variableNameToId.get(trimmedName);
+            if (!variableId) {
+                return match;
+            }
+            const value = this.variables.get(variableId);
+            if (value === undefined) {
+                return match;
+            }
+            const variable = this.variableDefinitions.get(variableId);
+            if (!variable) {
+                return match;
+            }
+            if (variable.type === "choice" && typeof value === "string") {
+                const choice = (_a = variable.choices) === null || _a === void 0 ? void 0 : _a.find((c) => c.id === value);
+                return choice ? choice.label : match;
+            }
+            return String(value);
+        });
+    }
+    getVariablesMap() {
+        return new Map(this.variables);
+    }
+    reset() {
+        for (const [id, variable] of this.variableDefinitions) {
+            this.variables.set(id, this.getDefaultValue(variable));
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luna-editor/engine",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Luna Editor scenario playback engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/components/ConversationLogUI.d.ts

@@ -1,2 +0,0 @@
-import type React from "react";
-export declare const ConversationLogUI: React.FC;