Refactored events model and added a basic view for it behind a feature flag.

src/core/data_formats/parsing/quest/dat.ts

@@ -55,14 +55,14 @@ export enum DatEventActionType {
     SpawnNpcs = 0x8,
     Unlock = 0xa,
     Lock = 0xb,
-    SpawnWave = 0xc,
+    TriggerEvent = 0xc,
 }
 
 export type DatEventAction =
     | DatEventActionSpawnNpcs
     | DatEventActionUnlock
     | DatEventActionLock
-    | DatEventActionSpawnWave;
+    | DatEventActionTriggerEvent;
 
 export type DatEventActionSpawnNpcs = {
     readonly type: DatEventActionType.SpawnNpcs;
@@ -80,9 +80,9 @@ export type DatEventActionLock = {
     readonly door_id: number;
 };
 
-export type DatEventActionSpawnWave = {
+export type DatEventActionTriggerEvent = {
-    readonly type: DatEventActionType.SpawnWave;
+    readonly type: DatEventActionType.TriggerEvent;
-    readonly wave_id: number;
+    readonly event_id: number;
 };
 
 export type DatUnknown = {
@@ -344,10 +344,10 @@ function parse_wave_actions(cursor: Cursor): DatEventAction[] {
                 });
                 break;
 
-            case DatEventActionType.SpawnWave:
+            case DatEventActionType.TriggerEvent:
                 actions.push({
-                    type: DatEventActionType.SpawnWave,
+                    type: DatEventActionType.TriggerEvent,
-                    wave_id: cursor.u32(),
+                    event_id: cursor.u32(),
                 });
                 break;
 
@@ -519,8 +519,8 @@ function write_waves(cursor: WritableCursor, waves: readonly DatEvent[]): void {
                         cursor.write_u16(action.door_id);
                         break;
 
-                    case DatEventActionType.SpawnWave:
+                    case DatEventActionType.TriggerEvent:
-                        cursor.write_u32(action.wave_id);
+                        cursor.write_u32(action.event_id);
                         break;
 
                     default:

src/core/data_formats/parsing/quest/index.ts

@@ -32,7 +32,7 @@ export type Quest = {
     readonly episode: Episode;
     readonly objects: readonly QuestObject[];
     readonly npcs: readonly QuestNpc[];
-    readonly waves: readonly QuestEvent[];
+    readonly events: readonly QuestEvent[];
     /**
      * (Partial) raw DAT data that can't be parsed yet by Phantasmal.
      */
@@ -127,7 +127,7 @@ export function parse_quest(cursor: Cursor, lenient: boolean = false): Quest | u
         episode,
         objects,
         npcs: parse_npc_data(episode, dat.npcs),
-        waves: dat.waves,
+        events: dat.waves,
         dat_unknowns: dat.unknowns,
         object_code: bin.object_code,
         shop_items: bin.shop_items,
@@ -139,7 +139,7 @@ export function write_quest_qst(quest: Quest, file_name: string): ArrayBuffer {
     const dat = write_dat({
         objs: objects_to_dat_data(quest.objects),
         npcs: npcs_to_dat_data(quest.npcs),
-        waves: quest.waves,
+        waves: quest.events,
         unknowns: quest.dat_unknowns,
     });
     const bin = write_bin({

src/core/gui/Widget.ts

@@ -82,6 +82,7 @@ export abstract class Widget implements Disposable {
     protected finalize_construction(proto: any): void {
         if (Object.getPrototypeOf(this) !== proto) return;
 
+        // At this point we know `this.element` is initialized.
         if (this.options.class) {
             this.element.classList.add(this.options.class);
         }

src/core/gui/dom.ts

@@ -103,24 +103,28 @@ export function create_element<T extends HTMLElement>(
     const element = document.createElement(tag_name) as any;
 
     if (attributes) {
-        if (attributes.class != undefined) element.className = attributes.class;
+        if (attributes instanceof HTMLElement) {
-        if (attributes.text != undefined) element.textContent = attributes.text;
+            element.append(attributes);
-        if (attributes.title != undefined) element.title = attributes.title;
+        } else {
-        if (attributes.href != undefined) element.href = attributes.href;
+            if (attributes.class != undefined) element.className = attributes.class;
-        if (attributes.src != undefined) element.src = attributes.src;
+            if (attributes.text != undefined) element.textContent = attributes.text;
-        if (attributes.width != undefined) element.width = attributes.width;
+            if (attributes.title != undefined) element.title = attributes.title;
-        if (attributes.height != undefined) element.height = attributes.height;
+            if (attributes.href != undefined) element.href = attributes.href;
-        if (attributes.alt != undefined) element.alt = attributes.alt;
+            if (attributes.src != undefined) element.src = attributes.src;
+            if (attributes.width != undefined) element.width = attributes.width;
+            if (attributes.height != undefined) element.height = attributes.height;
+            if (attributes.alt != undefined) element.alt = attributes.alt;
 
-        if (attributes.data) {
+            if (attributes.data) {
-            for (const [key, val] of Object.entries(attributes.data)) {
+                for (const [key, val] of Object.entries(attributes.data)) {
-                element.dataset[key] = val;
+                    element.dataset[key] = val;
+                }
             }
+
+            if (attributes.col_span != undefined) element.colSpan = attributes.col_span;
+
+            if (attributes.tab_index != undefined) element.tabIndex = attributes.tab_index;
         }
-
-        if (attributes.col_span != undefined) element.colSpan = attributes.col_span;
-
-        if (attributes.tab_index != undefined) element.tabIndex = attributes.tab_index;
     }
 
     element.append(...children);
@@ -137,39 +141,41 @@ export function bind_hidden(element: HTMLElement, observable: Observable<boolean
 }
 
 export enum Icon {
+    ArrowDown,
     File,
+    GitHub,
     NewFile,
-    Save,
+    Play,
-    TriangleUp,
+    Plus,
-    TriangleDown,
-    Undo,
     Redo,
     Remove,
-    GitHub,
+    Save,
-    Play,
+    TriangleDown,
+    TriangleUp,
+    Undo,
 }
 
 export function icon(icon: Icon): HTMLElement {
     let icon_str!: string;
 
     switch (icon) {
+        case Icon.ArrowDown:
+            icon_str = "fas fa-arrow-down";
+            break;
         case Icon.File:
             icon_str = "fas fa-file";
             break;
+        case Icon.GitHub:
+            icon_str = "fab fa-github";
+            break;
         case Icon.NewFile:
             icon_str = "fas fa-file-medical";
             break;
-        case Icon.Save:
+        case Icon.Play:
-            icon_str = "fas fa-save";
+            icon_str = "fas fa-play";
             break;
-        case Icon.TriangleUp:
+        case Icon.Plus:
-            icon_str = "fas fa-caret-up";
+            icon_str = "fas fa-plus";
-            break;
-        case Icon.TriangleDown:
-            icon_str = "fas fa-caret-down";
-            break;
-        case Icon.Undo:
-            icon_str = "fas fa-undo";
             break;
         case Icon.Redo:
             icon_str = "fas fa-redo";
@@ -177,11 +183,17 @@ export function icon(icon: Icon): HTMLElement {
         case Icon.Remove:
             icon_str = "fas fa-trash-alt";
             break;
-        case Icon.GitHub:
+        case Icon.Save:
-            icon_str = "fab fa-github";
+            icon_str = "fas fa-save";
             break;
-        case Icon.Play:
+        case Icon.TriangleDown:
-            icon_str = "fas fa-play";
+            icon_str = "fas fa-caret-down";
+            break;
+        case Icon.TriangleUp:
+            icon_str = "fas fa-caret-up";
+            break;
+        case Icon.Undo:
+            icon_str = "fas fa-undo";
             break;
     }
 

src/core/gui/golden_layout_theme.css

@@ -32,6 +32,10 @@
     border-bottom-color: var(--bg-color);
 }
 
+#root .lm_header .lm_controls > li {
+    cursor: default;
+}
+
 #root .lm_content {
     overflow: visible;
 }

src/quest_editor/gui/EventsView.css

@@ -0,0 +1,33 @@
+.quest_editor_EventsView {
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+
+.quest_editor_EventsView_chain {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    margin: 3px;
+}
+
+.quest_editor_EventsView_chain_arrow {
+    font-size: 18px; /* For icon */
+    margin: 3px;
+}
+
+.quest_editor_EventsView_event:last-of-type .quest_editor_EventsView_chain_arrow {
+    color: var(--text-color-disabled);
+}
+
+.quest_editor_EventsView_event {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    width: 100%;
+}
+
+.quest_editor_EventsView_event th {
+    text-align: left;
+}

src/quest_editor/gui/EventsView.ts

@@ -0,0 +1,71 @@
+import { ResizableWidget } from "../../core/gui/ResizableWidget";
+import { bind_children_to, el, icon, Icon } from "../../core/gui/dom";
+import { quest_editor_store } from "../stores/QuestEditorStore";
+import { QuestEventChainModel } from "../model/QuestEventChainModel";
+import { Disposer } from "../../core/observable/Disposer";
+import { NumberInput } from "../../core/gui/NumberInput";
+import "./EventsView.css";
+import { Button } from "../../core/gui/Button";
+import { Disposable } from "../../core/observable/Disposable";
+
+export class EventsView extends ResizableWidget {
+    private readonly quest_disposer = this.disposable(new Disposer());
+
+    readonly element = el.div({ class: "quest_editor_EventsView" });
+
+    constructor() {
+        super();
+
+        this.disposables(
+            quest_editor_store.current_quest.observe(({ value: quest }) => {
+                this.quest_disposer.dispose_all();
+
+                if (quest) {
+                    this.quest_disposer.add(
+                        bind_children_to(
+                            this.element,
+                            quest.event_chains,
+                            this.create_chain_element,
+                        ),
+                    );
+                }
+            }),
+        );
+
+        this.finalize_construction(EventsView.prototype);
+    }
+
+    private create_chain_element = (chain: QuestEventChainModel): [HTMLElement, Disposable] => {
+        const disposer = new Disposer();
+        const element = el.div(
+            { class: "quest_editor_EventsView_chain" },
+            ...chain.events.val.map(event =>
+                el.div(
+                    { class: "quest_editor_EventsView_event" },
+                    el.table(
+                        el.tr(el.th({ text: "ID:" }), el.td({ text: event.id.toString() })),
+                        el.tr(
+                            el.th({ text: "Section:" }),
+                            el.td(
+                                disposer.add(new NumberInput(event.section_id, { enabled: false }))
+                                    .element,
+                            ),
+                        ),
+                        el.tr(el.th({ text: "Wave:" }), el.td({ text: event.wave.toString() })),
+                        el.tr(
+                            el.th({ text: "Delay:" }),
+                            el.td(
+                                disposer.add(new NumberInput(event.delay, { enabled: false }))
+                                    .element,
+                            ),
+                        ),
+                    ),
+                    el.div({ class: "quest_editor_EventsView_chain_arrow" }, icon(Icon.ArrowDown)),
+                ),
+            ),
+            disposer.add(new Button("Add event", { icon_left: Icon.Plus, enabled: false })).element,
+        );
+
+        return [element, disposer];
+    };
+}

src/quest_editor/gui/QuestEditorView.ts

@@ -14,6 +14,7 @@ import { gui_store, GuiTool } from "../../core/stores/GuiStore";
 import { quest_editor_store } from "../stores/QuestEditorStore";
 import { NpcListView } from "./NpcListView";
 import { ObjectListView } from "./ObjectListView";
+import { EventsView } from "./EventsView";
 import Logger = require("js-logger");
 
 const logger = Logger.get("quest_editor/gui/QuestEditorView");
@@ -29,6 +30,10 @@ const VIEW_TO_NAME = new Map<new () => ResizableWidget, string>([
     [ObjectListView, "object_list_view"],
 ]);
 
+if (gui_store.feature_active("events")) {
+    VIEW_TO_NAME.set(EventsView, "events_view");
+}
+
 const DEFAULT_LAYOUT_CONFIG = {
     settings: {
         showPopoutIcon: false,
@@ -50,19 +55,30 @@ const DEFAULT_LAYOUT_CONTENT: ItemConfigType[] = [
         type: "row",
         content: [
             {
-                type: "stack",
+                type: "column",
-                width: 3,
+                width: 2,
                 content: [
                     {
-                        title: "Info",
+                        type: "stack",
-                        type: "component",
+                        content: [
-                        componentName: VIEW_TO_NAME.get(QuestInfoView),
+                            {
-                        isClosable: false,
+                                title: "Info",
+                                type: "component",
+                                componentName: VIEW_TO_NAME.get(QuestInfoView),
+                                isClosable: false,
+                            },
+                            {
+                                title: "NPC Counts",
+                                type: "component",
+                                componentName: VIEW_TO_NAME.get(NpcCountsView),
+                                isClosable: false,
+                            },
+                        ],
                     },
                     {
-                        title: "NPC Counts",
+                        title: "Entity",
                         type: "component",
-                        componentName: VIEW_TO_NAME.get(NpcCountsView),
+                        componentName: VIEW_TO_NAME.get(EntityInfoView),
                         isClosable: false,
                     },
                 ],
@@ -89,12 +105,6 @@ const DEFAULT_LAYOUT_CONTENT: ItemConfigType[] = [
                 type: "stack",
                 width: 2,
                 content: [
-                    {
-                        title: "Entity",
-                        type: "component",
-                        componentName: VIEW_TO_NAME.get(EntityInfoView),
-                        isClosable: false,
-                    },
                     {
                         title: "NPCs",
                         type: "component",
@@ -107,6 +117,16 @@ const DEFAULT_LAYOUT_CONTENT: ItemConfigType[] = [
                         componentName: VIEW_TO_NAME.get(ObjectListView),
                         isClosable: false,
                     },
+                    ...(gui_store.feature_active("events")
+                        ? [
+                              {
+                                  title: "Events",
+                                  type: "component",
+                                  componentName: VIEW_TO_NAME.get(EventsView),
+                                  isClosable: false,
+                              },
+                          ]
+                        : []),
                 ],
             },
         ],

src/quest_editor/model/QuestEventActionModel.ts

@@ -31,13 +31,3 @@ export class QuestEventActionLockModel extends QuestEventActionModel {
         this.door_id = door_id;
     }
 }
-
-export class QuestEventActionSpawnWaveModel extends QuestEventActionModel {
-    readonly wave_id: number;
-
-    constructor(wave_id: number) {
-        super();
-
-        this.wave_id = wave_id;
-    }
-}

src/quest_editor/model/QuestEventChainModel.ts

@@ -0,0 +1,15 @@
+import { QuestEventModel } from "./QuestEventModel";
+import { ListProperty } from "../../core/observable/property/list/ListProperty";
+import { WritableListProperty } from "../../core/observable/property/list/WritableListProperty";
+import { list_property } from "../../core/observable";
+
+export class QuestEventChainModel {
+    private readonly _events: WritableListProperty<QuestEventModel>;
+
+    readonly events: ListProperty<QuestEventModel>;
+
+    constructor(events: QuestEventModel[]) {
+        this._events = list_property(undefined, ...events);
+        this.events = this._events;
+    }
+}

src/quest_editor/model/QuestModel.ts

@@ -13,7 +13,7 @@ import { ListProperty } from "../../core/observable/property/list/ListProperty";
 import { WritableListProperty } from "../../core/observable/property/list/WritableListProperty";
 import { QuestEntityModel } from "./QuestEntityModel";
 import { entity_type_to_string } from "../../core/data_formats/parsing/quest/entities";
-import { QuestEventModel } from "./QuestEventModel";
+import { QuestEventChainModel } from "./QuestEventChainModel";
 
 const logger = Logger.get("quest_editor/model/QuestModel");
 
@@ -27,7 +27,7 @@ export class QuestModel {
     private readonly _area_variants: WritableListProperty<AreaVariantModel> = list_property();
     private readonly _objects: WritableListProperty<QuestObjectModel>;
     private readonly _npcs: WritableListProperty<QuestNpcModel>;
-    private readonly _waves: WritableListProperty<QuestEventModel>;
+    private readonly _event_chains: WritableListProperty<QuestEventChainModel>;
 
     readonly id: Property<number> = this._id;
 
@@ -60,7 +60,7 @@ export class QuestModel {
 
     readonly npcs: ListProperty<QuestNpcModel>;
 
-    readonly waves: ListProperty<QuestEventModel>;
+    readonly event_chains: ListProperty<QuestEventChainModel>;
 
     /**
      * (Partial) raw DAT data that can't be parsed yet by Phantasmal.
@@ -81,7 +81,7 @@ export class QuestModel {
         map_designations: Map<number, number>,
         objects: readonly QuestObjectModel[],
         npcs: readonly QuestNpcModel[],
-        waves: readonly QuestEventModel[],
+        event_chains: readonly QuestEventChainModel[],
         dat_unknowns: readonly DatUnknown[],
         object_code: readonly Segment[],
         shop_items: readonly number[],
@@ -90,7 +90,7 @@ export class QuestModel {
         if (!map_designations) throw new Error("map_designations is required.");
         if (!Array.isArray(objects)) throw new Error("objs is required.");
         if (!Array.isArray(npcs)) throw new Error("npcs is required.");
-        if (!Array.isArray(waves)) throw new Error("waves is required.");
+        if (!Array.isArray(event_chains)) throw new Error("event_chains is required.");
         if (!Array.isArray(dat_unknowns)) throw new Error("dat_unknowns is required.");
         if (!Array.isArray(object_code)) throw new Error("object_code is required.");
         if (!Array.isArray(shop_items)) throw new Error("shop_items is required.");
@@ -107,8 +107,8 @@ export class QuestModel {
         this.objects = this._objects;
         this._npcs = list_property(undefined, ...npcs);
         this.npcs = this._npcs;
-        this._waves = list_property(undefined, ...waves);
+        this._event_chains = list_property(undefined, ...event_chains);
-        this.waves = this._waves;
+        this.event_chains = this._event_chains;
         this.dat_unknowns = dat_unknowns;
         this.object_code = object_code;
         this.shop_items = shop_items;

src/quest_editor/stores/QuestEditorStore.ts

@@ -26,17 +26,9 @@ import { create_new_quest } from "./quest_creation";
 import { CreateEntityAction } from "../actions/CreateEntityAction";
 import { RemoveEntityAction } from "../actions/RemoveEntityAction";
 import { Euler, Vector3 } from "three";
-import { vec3_to_threejs } from "../../core/rendering/conversion";
 import { RotateEntityAction } from "../actions/RotateEntityAction";
 import { ExecutionResult, VirtualMachine } from "../scripting/vm";
-import { QuestEventModel } from "../model/QuestEventModel";
+import { convert_quest_from_model, convert_quest_to_model } from "./model_conversion";
-import { DatEventActionType } from "../../core/data_formats/parsing/quest/dat";
-import {
-    QuestEventActionLockModel,
-    QuestEventActionSpawnNpcsModel,
-    QuestEventActionSpawnWaveModel,
-    QuestEventActionUnlockModel,
-} from "../model/QuestEventActionModel";
 import Logger = require("js-logger");
 
 const logger = Logger.get("quest_editor/gui/QuestEditorStore");
@@ -118,92 +110,7 @@ export class QuestEditorStore implements Disposable {
         try {
             const buffer = await read_file(file);
             const quest = parse_quest(new ArrayBufferCursor(buffer, Endianness.Little));
-            this.set_quest(
+            this.set_quest(quest && convert_quest_to_model(quest), file.name);
-                quest &&
-                    new QuestModel(
-                        quest.id,
-                        quest.language,
-                        quest.name,
-                        quest.short_description,
-                        quest.long_description,
-                        quest.episode,
-                        quest.map_designations,
-                        quest.objects.map(
-                            obj =>
-                                new QuestObjectModel(
-                                    obj.type,
-                                    obj.id,
-                                    obj.group_id,
-                                    obj.area_id,
-                                    obj.section_id,
-                                    vec3_to_threejs(obj.position),
-                                    new Euler(
-                                        obj.rotation.x,
-                                        obj.rotation.y,
-                                        obj.rotation.z,
-                                        "ZXY",
-                                    ),
-                                    obj.properties,
-                                    obj.unknown,
-                                ),
-                        ),
-                        quest.npcs.map(
-                            npc =>
-                                new QuestNpcModel(
-                                    npc.type,
-                                    npc.pso_type_id,
-                                    npc.npc_id,
-                                    npc.script_label,
-                                    npc.pso_roaming,
-                                    npc.area_id,
-                                    npc.section_id,
-                                    vec3_to_threejs(npc.position),
-                                    new Euler(
-                                        npc.rotation.x,
-                                        npc.rotation.y,
-                                        npc.rotation.z,
-                                        "ZXY",
-                                    ),
-                                    vec3_to_threejs(npc.scale),
-                                    npc.unknown,
-                                ),
-                        ),
-                        quest.waves.map(
-                            wave =>
-                                new QuestEventModel(
-                                    wave.id,
-                                    wave.section_id,
-                                    wave.wave,
-                                    wave.delay,
-                                    wave.actions.map(action => {
-                                        switch (action.type) {
-                                            case DatEventActionType.SpawnNpcs:
-                                                return new QuestEventActionSpawnNpcsModel(
-                                                    action.section_id,
-                                                    action.appear_flag,
-                                                );
-                                            case DatEventActionType.Unlock:
-                                                return new QuestEventActionUnlockModel(
-                                                    action.door_id,
-                                                );
-                                            case DatEventActionType.Lock:
-                                                return new QuestEventActionLockModel(action.door_id);
-                                            case DatEventActionType.SpawnWave:
-                                                return new QuestEventActionSpawnWaveModel(
-                                                    action.wave_id,
-                                                );
-                                        }
-                                    }),
-                                    wave.area_id,
-                                    wave.unknown,
-                                ),
-                        ),
-                        quest.dat_unknowns,
-                        quest.object_code,
-                        quest.shop_items,
-                    ),
-                file.name,
-            );
         } catch (e) {
             logger.error("Couldn't read file.", e);
         }
@@ -223,83 +130,7 @@ export class QuestEditorStore implements Disposable {
         let file_name = prompt("File name:", default_file_name);
         if (!file_name) return;
 
-        const buffer = write_quest_qst(
+        const buffer = write_quest_qst(convert_quest_from_model(quest), file_name);
-            {
-                id: quest.id.val,
-                language: quest.language.val,
-                name: quest.name.val,
-                short_description: quest.short_description.val,
-                long_description: quest.long_description.val,
-                episode: quest.episode,
-                objects: quest.objects.val.map(obj => ({
-                    type: obj.type,
-                    area_id: obj.area_id,
-                    section_id: obj.section_id.val,
-                    position: obj.position.val,
-                    rotation: obj.rotation.val,
-                    unknown: obj.unknown,
-                    id: obj.id,
-                    group_id: obj.group_id,
-                    properties: obj.properties,
-                })),
-                npcs: quest.npcs.val.map(npc => ({
-                    type: npc.type,
-                    area_id: npc.area_id,
-                    section_id: npc.section_id.val,
-                    position: npc.position.val,
-                    rotation: npc.rotation.val,
-                    scale: npc.scale,
-                    unknown: npc.unknown,
-                    pso_type_id: npc.pso_type_id,
-                    npc_id: npc.npc_id,
-                    script_label: npc.script_label,
-                    pso_roaming: npc.pso_roaming,
-                })),
-                waves: quest.waves.val.map(wave => ({
-                    id: wave.id,
-                    section_id: wave.section_id,
-                    wave: wave.wave,
-                    delay: wave.delay,
-                    actions: wave.actions.map(action => {
-                        if (action instanceof QuestEventActionSpawnNpcsModel) {
-                            return {
-                                type: DatEventActionType.SpawnNpcs,
-                                section_id: action.section_id,
-                                appear_flag: action.appear_flag,
-                            };
-                        } else if (action instanceof QuestEventActionUnlockModel) {
-                            return {
-                                type: DatEventActionType.Unlock,
-                                door_id: action.door_id,
-                            };
-                        } else if (action instanceof QuestEventActionLockModel) {
-                            return {
-                                type: DatEventActionType.Lock,
-                                door_id: action.door_id,
-                            };
-                        } else if (action instanceof QuestEventActionSpawnWaveModel) {
-                            return {
-                                type: DatEventActionType.SpawnWave,
-                                wave_id: action.wave_id,
-                            };
-                        } else {
-                            throw new Error(
-                                `Unknown wave action type ${
-                                    Object.getPrototypeOf(action).constructor
-                                }`,
-                            );
-                        }
-                    }),
-                    area_id: wave.area_id,
-                    unknown: wave.unknown,
-                })),
-                dat_unknowns: quest.dat_unknowns,
-                object_code: quest.object_code,
-                shop_items: quest.shop_items,
-                map_designations: quest.map_designations.val,
-            },
-            file_name,
-        );
 
         if (!file_name.endsWith(".qst")) {
             file_name += ".qst";

src/quest_editor/stores/model_conversion.ts

@@ -0,0 +1,205 @@
+import { Quest } from "../../core/data_formats/parsing/quest";
+import { QuestModel } from "../model/QuestModel";
+import { QuestObjectModel } from "../model/QuestObjectModel";
+import { vec3_to_threejs } from "../../core/rendering/conversion";
+import { Euler } from "three";
+import { QuestNpcModel } from "../model/QuestNpcModel";
+import { QuestEventModel } from "../model/QuestEventModel";
+import {
+    DatEventActionTriggerEvent,
+    DatEventActionType,
+} from "../../core/data_formats/parsing/quest/dat";
+import {
+    QuestEventActionLockModel,
+    QuestEventActionSpawnNpcsModel,
+    QuestEventActionUnlockModel,
+} from "../model/QuestEventActionModel";
+import { QuestEventChainModel } from "../model/QuestEventChainModel";
+import { QuestEvent } from "../../core/data_formats/parsing/quest/entities";
+import Logger from "js-logger";
+
+const logger = Logger.get("quest_editor/stores/model_conversion");
+
+export function convert_quest_to_model(quest: Quest): QuestModel {
+    // Build up event chains.
+    const events = quest.events.slice();
+    const event_chains: QuestEventChainModel[] = [];
+
+    while (events.length) {
+        let event: QuestEvent | undefined = events.shift();
+        const chain_events = [];
+
+        while (event) {
+            chain_events.push(
+                new QuestEventModel(
+                    event.id,
+                    event.section_id,
+                    event.wave,
+                    event.delay,
+                    event.actions
+                        .filter(action => action.type !== DatEventActionType.TriggerEvent)
+                        .map(action => {
+                            switch (action.type) {
+                                case DatEventActionType.SpawnNpcs:
+                                    return new QuestEventActionSpawnNpcsModel(
+                                        action.section_id,
+                                        action.appear_flag,
+                                    );
+                                case DatEventActionType.Unlock:
+                                    return new QuestEventActionUnlockModel(action.door_id);
+                                case DatEventActionType.Lock:
+                                    return new QuestEventActionLockModel(action.door_id);
+                                case DatEventActionType.TriggerEvent:
+                                    throw new Error("Can't convert trigger event actions.");
+                            }
+                        }),
+                    event.area_id,
+                    event.unknown,
+                ),
+            );
+
+            const event_id = event.id;
+
+            const trigger_event_actions = event.actions.filter(
+                action => action.type === DatEventActionType.TriggerEvent,
+            ) as DatEventActionTriggerEvent[];
+
+            event = undefined;
+
+            if (trigger_event_actions.length >= 1) {
+                if (trigger_event_actions.length > 1) {
+                    logger.warn(`Event ${event_id} has more than 1 trigger event action.`);
+                }
+
+                const index = events.findIndex(e => e.id === trigger_event_actions[0].event_id);
+
+                if (index !== -1) {
+                    event = events.splice(index, 1)[0];
+                }
+            }
+        }
+
+        const chain = new QuestEventChainModel(chain_events);
+        event_chains.push(chain);
+    }
+
+    // Create quest model.
+    return new QuestModel(
+        quest.id,
+        quest.language,
+        quest.name,
+        quest.short_description,
+        quest.long_description,
+        quest.episode,
+        quest.map_designations,
+        quest.objects.map(
+            obj =>
+                new QuestObjectModel(
+                    obj.type,
+                    obj.id,
+                    obj.group_id,
+                    obj.area_id,
+                    obj.section_id,
+                    vec3_to_threejs(obj.position),
+                    new Euler(obj.rotation.x, obj.rotation.y, obj.rotation.z, "ZXY"),
+                    obj.properties,
+                    obj.unknown,
+                ),
+        ),
+        quest.npcs.map(
+            npc =>
+                new QuestNpcModel(
+                    npc.type,
+                    npc.pso_type_id,
+                    npc.npc_id,
+                    npc.script_label,
+                    npc.pso_roaming,
+                    npc.area_id,
+                    npc.section_id,
+                    vec3_to_threejs(npc.position),
+                    new Euler(npc.rotation.x, npc.rotation.y, npc.rotation.z, "ZXY"),
+                    vec3_to_threejs(npc.scale),
+                    npc.unknown,
+                ),
+        ),
+        event_chains,
+        quest.dat_unknowns,
+        quest.object_code,
+        quest.shop_items,
+    );
+}
+
+export function convert_quest_from_model(quest: QuestModel): Quest {
+    return {
+        id: quest.id.val,
+        language: quest.language.val,
+        name: quest.name.val,
+        short_description: quest.short_description.val,
+        long_description: quest.long_description.val,
+        episode: quest.episode,
+        objects: quest.objects.val.map(obj => ({
+            type: obj.type,
+            area_id: obj.area_id,
+            section_id: obj.section_id.val,
+            position: obj.position.val,
+            rotation: obj.rotation.val,
+            unknown: obj.unknown,
+            id: obj.id,
+            group_id: obj.group_id,
+            properties: obj.properties,
+        })),
+        npcs: quest.npcs.val.map(npc => ({
+            type: npc.type,
+            area_id: npc.area_id,
+            section_id: npc.section_id.val,
+            position: npc.position.val,
+            rotation: npc.rotation.val,
+            scale: npc.scale,
+            unknown: npc.unknown,
+            pso_type_id: npc.pso_type_id,
+            npc_id: npc.npc_id,
+            script_label: npc.script_label,
+            pso_roaming: npc.pso_roaming,
+        })),
+        events: quest.waves.val.map(wave => ({
+            id: wave.id,
+            section_id: wave.section_id,
+            wave: wave.wave,
+            delay: wave.delay,
+            actions: wave.actions.map(action => {
+                if (action instanceof QuestEventActionSpawnNpcsModel) {
+                    return {
+                        type: DatEventActionType.SpawnNpcs,
+                        section_id: action.section_id,
+                        appear_flag: action.appear_flag,
+                    };
+                } else if (action instanceof QuestEventActionUnlockModel) {
+                    return {
+                        type: DatEventActionType.Unlock,
+                        door_id: action.door_id,
+                    };
+                } else if (action instanceof QuestEventActionLockModel) {
+                    return {
+                        type: DatEventActionType.Lock,
+                        door_id: action.door_id,
+                    };
+                } else if (action instanceof QuestEventActionTriggerEventModel) {
+                    return {
+                        type: DatEventActionType.TriggerEvent,
+                        wave_id: action.wave_id,
+                    };
+                } else {
+                    throw new Error(
+                        `Unknown event action type ${Object.getPrototypeOf(action).constructor}`,
+                    );
+                }
+            }),
+            area_id: wave.area_id,
+            unknown: wave.unknown,
+        })),
+        dat_unknowns: quest.dat_unknowns,
+        object_code: quest.object_code,
+        shop_items: quest.shop_items,
+        map_designations: quest.map_designations.val,
+    };
+}