Entity-specific properties are now shown in the entity info view for supported entities.

FEATURES.md

@@ -155,7 +155,8 @@ Features that are in ***bold italics*** are planned but not yet implemented.
 ## Bugs
 
 - [Load Quest](#load-quest): Can't parse quest 125 White Day
-- [Script Assembly Editor](#script-assembly-editor): Go to definition doesn't work in RT (#231) and PW2 (#234)
+- [Script Assembly Editor](#script-assembly-editor): Go to definition doesn't work in RT (#231), PW2
+(#234) and Magnitude of Metal (#1, can jump to label 207 from line 433, but not from line 465)
 - When a modal dialog is open, global keybindings should be disabled
 - Entities with rendering issues:
     - Caves 4 Button door
@@ -174,3 +175,4 @@ Features that are in ***bold italics*** are planned but not yet implemented.
     - Merissa A
     - Merissa AA
 - All "Sonic" objects, even the ones that aren't actually Sonic, are rendered as Sonic
+- [Event Actions](#Event Actions): Editing event actions can't be undone

README.md

@@ -71,7 +71,7 @@ re-run whenever a file is changed. The testing framework used is Jest.
 
 ### Code Style, Linting and Formatting
 
-Class names are in `PascalCase` and all other identifiers are in `snake_case`.
+Class/interface/type names are in `PascalCase` and all other identifiers are in `snake_case`.
 
 ESLint and Prettier are used for linting and formatting. Run with `yarn lint` and/or configure your
 editor to use the ESLint/Prettier configuration.
@@ -84,4 +84,6 @@ Create an optimized production build with `yarn build`.
 
 ### prs-rs
 
-Provides faster PRS routines using WebAssembly. Build for WebPack with `yarn build_prs_rs_browser`. Build for Jest with `yarn build_prs_rs_testing`. Building requires [wasm-pack](https://github.com/rustwasm/wasm-pack).
+Provides faster PRS routines using WebAssembly. Build for WebPack with `yarn build_prs_rs_browser`.
+Build for Jest with `yarn build_prs_rs_testing`. Building requires
+[wasm-pack](https://github.com/rustwasm/wasm-pack).

src/core/data_formats/parsing/area_geometry.ts

@@ -1,8 +1,9 @@
 import { Cursor } from "../block/cursor/Cursor";
 import { Vec3 } from "../vector";
-import { ANGLE_TO_RAD, NjObject, parse_xj_object } from "./ninja";
+import { NjObject, parse_xj_object } from "./ninja";
 import { XjModel } from "./ninja/xj";
 import { parse_rel } from "./rel";
+import { angle_to_rad } from "./ninja/angle";
 
 export type RenderObject = {
     sections: RenderSection[];
@@ -34,9 +35,9 @@ export function parse_area_geometry(cursor: Cursor): RenderObject {
         const section_id = cursor.i32();
         const section_position = cursor.vec3_f32();
         const section_rotation = {
-            x: cursor.u32() * ANGLE_TO_RAD,
-            y: cursor.u32() * ANGLE_TO_RAD,
-            z: cursor.u32() * ANGLE_TO_RAD,
+            x: angle_to_rad(cursor.u32()),
+            y: angle_to_rad(cursor.u32()),
+            z: angle_to_rad(cursor.u32()),
         };
 
         cursor.seek(4);

src/core/data_formats/parsing/ninja/angle.ts

@@ -0,0 +1,10 @@
+const ANGLE_TO_RAD = (2 * Math.PI) / 0x10000;
+const RAD_TO_ANGLE = 0x10000 / (2 * Math.PI);
+
+export function angle_to_rad(angle: number): number {
+    return angle * ANGLE_TO_RAD;
+}
+
+export function rad_to_angle(rad: number): number {
+    return Math.round(rad * RAD_TO_ANGLE);
+}

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

@@ -4,8 +4,7 @@ import { parse_iff } from "../iff";
 import { NjcmModel, parse_njcm_model } from "./njcm";
 import { parse_xj_model, XjModel } from "./xj";
 import { Result, success } from "../../../Result";
-
-export const ANGLE_TO_RAD = (2 * Math.PI) / 0xffff;
+import { angle_to_rad } from "./angle";
 
 const NJCM = 0x4d434a4e;
 
@@ -159,9 +158,9 @@ function parse_sibling_objects<M extends NjModel>(
     const model_offset = cursor.u32();
     const pos = cursor.vec3_f32();
     const rotation = {
-        x: cursor.i32() * ANGLE_TO_RAD,
-        y: cursor.i32() * ANGLE_TO_RAD,
-        z: cursor.i32() * ANGLE_TO_RAD,
+        x: angle_to_rad(cursor.i32()),
+        y: angle_to_rad(cursor.i32()),
+        z: angle_to_rad(cursor.i32()),
     };
     const scale = cursor.vec3_f32();
     const child_offset = cursor.u32();

src/core/data_formats/parsing/ninja/motion.ts

@@ -1,6 +1,6 @@
-import { ANGLE_TO_RAD } from "./index";
 import { Cursor } from "../../block/cursor/Cursor";
 import { Vec3 } from "../../vector";
+import { angle_to_rad } from "./angle";
 
 const NMDM = 0x4d444d4e;
 
@@ -210,9 +210,9 @@ function parse_motion_data_a(
         frames.push({
             frame: cursor.u16(),
             value: {
-                x: cursor.u16() * ANGLE_TO_RAD,
-                y: cursor.u16() * ANGLE_TO_RAD,
-                z: cursor.u16() * ANGLE_TO_RAD,
+                x: angle_to_rad(cursor.u16()),
+                y: angle_to_rad(cursor.u16()),
+                z: angle_to_rad(cursor.u16()),
             },
         });
     }
@@ -238,9 +238,9 @@ function parse_motion_data_a_wide(cursor: Cursor, keyframe_count: number): NjKey
         frames.push({
             frame: cursor.u32(),
             value: {
-                x: cursor.i32() * ANGLE_TO_RAD,
-                y: cursor.i32() * ANGLE_TO_RAD,
-                z: cursor.i32() * ANGLE_TO_RAD,
+                x: angle_to_rad(cursor.i32()),
+                y: angle_to_rad(cursor.i32()),
+                z: angle_to_rad(cursor.i32()),
             },
         });
     }

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

@@ -1,10 +1,13 @@
 import { npc_data, NpcType, NpcTypeData } from "./npc_types";
 import { object_data, ObjectType, ObjectTypeData } from "./object_types";
-import { DatEvent, DatUnknown } from "./dat";
+import { DatEvent, DatUnknown, NPC_BYTE_SIZE } from "./dat";
 import { Episode } from "./Episode";
 import { Segment } from "../../asm/instructions";
-import { QuestNpc } from "./QuestNpc";
-import { QuestObject } from "./QuestObject";
+import { get_npc_type, QuestNpc } from "./QuestNpc";
+import { get_object_type, QuestObject } from "./QuestObject";
+import { EntityProp, EntityPropType } from "./properties";
+import { angle_to_rad, rad_to_angle } from "../ninja/angle";
+import { assert, require_finite, require_integer } from "../../../util";
 
 export type Quest = {
     id: number;
@@ -48,3 +51,72 @@ export function is_object_type(entity_type: EntityType): entity_type is ObjectTy
 export function entity_data(type: EntityType): EntityTypeData {
     return npc_data(type as NpcType) ?? object_data(type as ObjectType);
 }
+
+export function get_entity_type(entity: QuestEntity): EntityType {
+    return entity.data.byteLength === NPC_BYTE_SIZE
+        ? get_npc_type(entity as QuestNpc)
+        : get_object_type(entity as QuestObject);
+}
+
+export function get_entity_prop_value(entity: QuestEntity, prop: EntityProp): number {
+    switch (prop.type) {
+        case EntityPropType.U8:
+            return entity.view.getUint8(prop.offset);
+        case EntityPropType.U16:
+            return entity.view.getUint16(prop.offset, true);
+        case EntityPropType.U32:
+            return entity.view.getUint32(prop.offset, true);
+        case EntityPropType.I8:
+            return entity.view.getInt8(prop.offset);
+        case EntityPropType.I16:
+            return entity.view.getInt16(prop.offset, true);
+        case EntityPropType.I32:
+            return entity.view.getInt32(prop.offset, true);
+        case EntityPropType.F32:
+            return entity.view.getFloat32(prop.offset, true);
+        case EntityPropType.Angle:
+            return angle_to_rad(entity.view.getInt32(prop.offset, true));
+    }
+}
+
+export function set_entity_prop_value(entity: QuestEntity, prop: EntityProp, value: number): void {
+    switch (prop.type) {
+        case EntityPropType.U8:
+            require_in_bounds(value, 0, 0xff);
+            entity.view.setUint8(prop.offset, value);
+            break;
+        case EntityPropType.U16:
+            require_in_bounds(value, 0, 0xffff);
+            entity.view.setUint16(prop.offset, value, true);
+            break;
+        case EntityPropType.U32:
+            require_in_bounds(value, 0, 0xffffffff);
+            entity.view.setUint32(prop.offset, value, true);
+            break;
+        case EntityPropType.I8:
+            require_in_bounds(value, -0x80, 0x7f);
+            entity.view.setInt8(prop.offset, value);
+            break;
+        case EntityPropType.I16:
+            require_in_bounds(value, -0x8000, 0x7fff);
+            entity.view.setInt16(prop.offset, value, true);
+            break;
+        case EntityPropType.I32:
+            require_in_bounds(value, -0x80000000, 0x7fffffff);
+            entity.view.setInt32(prop.offset, value, true);
+            break;
+        case EntityPropType.F32:
+            entity.view.setFloat32(prop.offset, value, true);
+            break;
+        case EntityPropType.Angle:
+            require_finite(value, "value");
+            entity.view.setInt32(prop.offset, rad_to_angle(value), true);
+            break;
+    }
+}
+
+function require_in_bounds(value: unknown, min: number, max: number): asserts value is number {
+    require_integer(value, "value");
+    assert(value >= min, () => `value should be greater than or equal to ${min} but was ${value}.`);
+    assert(value <= max, () => `value should be less than or equal to ${max} but was ${value}.`);
+}

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

@@ -3,6 +3,7 @@ import { Vec3 } from "../../vector";
 import { Episode } from "./Episode";
 import { NPC_BYTE_SIZE } from "./dat";
 import { assert } from "../../../util";
+import { angle_to_rad, rad_to_angle } from "../ninja/angle";
 
 const DEFAULT_SCALE: Vec3 = Object.freeze({ x: 1, y: 1, z: 1 });
 
@@ -103,16 +104,16 @@ export function set_npc_position(npc: QuestNpc, position: Vec3): void {
 
 export function get_npc_rotation(npc: QuestNpc): Vec3 {
     return {
-        x: (npc.view.getInt32(32, true) / 0xffff) * 2 * Math.PI,
-        y: (npc.view.getInt32(36, true) / 0xffff) * 2 * Math.PI,
-        z: (npc.view.getInt32(40, true) / 0xffff) * 2 * Math.PI,
+        x: angle_to_rad(npc.view.getInt32(32, true)),
+        y: angle_to_rad(npc.view.getInt32(36, true)),
+        z: angle_to_rad(npc.view.getInt32(40, true)),
     };
 }
 
 export function set_npc_rotation(npc: QuestNpc, rotation: Vec3): void {
-    npc.view.setInt32(32, Math.round((rotation.x / (2 * Math.PI)) * 0xffff), true);
-    npc.view.setInt32(36, Math.round((rotation.y / (2 * Math.PI)) * 0xffff), true);
-    npc.view.setInt32(40, Math.round((rotation.z / (2 * Math.PI)) * 0xffff), true);
+    npc.view.setInt32(32, rad_to_angle(rotation.x), true);
+    npc.view.setInt32(36, rad_to_angle(rotation.y), true);
+    npc.view.setInt32(40, rad_to_angle(rotation.z), true);
 }
 
 /**

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

@@ -2,6 +2,7 @@ import { id_to_object_type, object_data, ObjectType } from "./object_types";
 import { Vec3 } from "../../vector";
 import { OBJECT_BYTE_SIZE } from "./dat";
 import { assert } from "../../../util";
+import { angle_to_rad, rad_to_angle } from "../ninja/angle";
 
 export type QuestObject = {
     area_id: number;
@@ -82,20 +83,20 @@ export function set_object_position(object: QuestObject, position: Vec3): void {
 
 export function get_object_rotation(object: QuestObject): Vec3 {
     return {
-        x: (object.view.getInt32(28, true) / 0xffff) * 2 * Math.PI,
-        y: (object.view.getInt32(32, true) / 0xffff) * 2 * Math.PI,
-        z: (object.view.getInt32(36, true) / 0xffff) * 2 * Math.PI,
+        x: angle_to_rad(object.view.getInt32(28, true)),
+        y: angle_to_rad(object.view.getInt32(32, true)),
+        z: angle_to_rad(object.view.getInt32(36, true)),
     };
 }
 
 export function set_object_rotation(object: QuestObject, rotation: Vec3): void {
-    object.view.setInt32(28, Math.round((rotation.x / (2 * Math.PI)) * 0xffff), true);
-    object.view.setInt32(32, Math.round((rotation.y / (2 * Math.PI)) * 0xffff), true);
-    object.view.setInt32(36, Math.round((rotation.z / (2 * Math.PI)) * 0xffff), true);
+    object.view.setInt32(28, rad_to_angle(rotation.x), true);
+    object.view.setInt32(32, rad_to_angle(rotation.y), true);
+    object.view.setInt32(36, rad_to_angle(rotation.z), true);
 }
 
 //
-// Complex properties that use multiple parts of the data block and possible other properties.
+// Complex properties that use multiple parts of the data block and possibly other properties.
 //
 
 export function get_object_type(object: QuestObject): ObjectType {

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

@@ -1,4 +1,5 @@
 import { check_episode, Episode } from "./Episode";
+import { EntityProp } from "./properties";
 
 // Make sure ObjectType does not overlap NpcType.
 export enum NpcType {
@@ -222,6 +223,10 @@ export type NpcTypeData = {
      * Slime).
      */
     readonly regular?: boolean;
+    /**
+     * Default object-specific properties.
+     */
+    readonly properties: readonly EntityProp[];
 };
 
 export const NPC_TYPES: NpcType[] = [];
@@ -279,6 +284,7 @@ function define_npc_type_data(
         type_id,
         skin,
         regular,
+        properties: [],
     });
 
     if (episode) {

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

@@ -0,0 +1,23 @@
+/**
+ * Represents a configurable property for accessing parts of entity data of which the use is not
+ * fully understood or ambiguous.
+ */
+export type EntityProp = {
+    readonly name: string;
+    readonly offset: number;
+    readonly type: EntityPropType;
+};
+
+export enum EntityPropType {
+    U8,
+    U16,
+    U32,
+    I8,
+    I16,
+    I32,
+    F32,
+    /**
+     * Signed 32-bit integer that represents an angle. 0x10000 is 360°.
+     */
+    Angle,
+}

src/core/util.ts

@@ -104,17 +104,24 @@ export function defined<T>(value: T | undefined | null, name: string): asserts v
     assert(value != undefined, () => `${name} should not be null or undefined (was ${value}).`);
 }
 
-export function require_finite(value: number, name: string): void {
+export function require_finite(value: unknown, name: string): asserts value is number {
     assert(Number.isFinite(value), () => `${name} should be a finite number (was ${value}).`);
 }
 
-export function require_integer(value: number, name: string): void {
+export function require_number(value: unknown, name: string): asserts value is number {
+    assert(typeof value === "number", () => `${name} should be a number (was ${value}).`);
+}
+
+export function require_integer(value: unknown, name: string): asserts value is number {
     assert(Number.isInteger(value), () => `${name} should be an integer (was ${value}).`);
 }
 
-export function require_non_negative_integer(value: number, name: string): void {
+export function require_non_negative_integer(
+    value: unknown,
+    name: string,
+): asserts value is number {
     assert(
-        Number.isInteger(value) && value >= 0,
+        Number.isInteger(value) && (value as any) >= 0,
         () => `${name} should be a non-negative integer (was ${value}).`,
     );
 }

src/quest_editor/controllers/EntityInfoController.ts

@@ -2,13 +2,15 @@ import { Controller } from "../../core/controllers/Controller";
 import { QuestEditorStore } from "../stores/QuestEditorStore";
 import { Property } from "../../core/observable/property/Property";
 import { QuestNpcModel } from "../model/QuestNpcModel";
-import { property } from "../../core/observable";
+import { flat_map_to_list, list_property, property } from "../../core/observable";
 import { Euler, Vector3 } from "three";
 import { deg_to_rad } from "../../core/math";
 import { TranslateEntityAction } from "../actions/TranslateEntityAction";
 import { RotateEntityAction } from "../actions/RotateEntityAction";
 import { euler } from "../model/euler";
 import { entity_data } from "../../core/data_formats/parsing/quest/Quest";
+import { ListProperty } from "../../core/observable/property/list/ListProperty";
+import { QuestEntityPropModel } from "../model/QuestEntityPropModel";
 
 const DUMMY_VECTOR = Object.freeze(new Vector3());
 const DUMMY_EULER = Object.freeze(new Euler());
@@ -23,6 +25,7 @@ export class EntityInfoController extends Controller {
     readonly wave_hidden: Property<boolean>;
     readonly position: Property<Vector3>;
     readonly rotation: Property<Euler>;
+    readonly props: ListProperty<QuestEntityPropModel>;
 
     constructor(private readonly store: QuestEditorStore) {
         super();
@@ -44,6 +47,7 @@ export class EntityInfoController extends Controller {
         this.wave_hidden = entity.map(e => !(e instanceof QuestNpcModel));
         this.position = entity.flat_map(e => e?.position ?? property(DUMMY_VECTOR));
         this.rotation = entity.flat_map(e => e?.rotation ?? property(DUMMY_EULER));
+        this.props = flat_map_to_list(e => e?.props ?? list_property(), entity);
     }
 
     focused = (): void => {

src/quest_editor/gui/EntityInfoView.ts

@@ -1,17 +1,22 @@
-import { bind_attr, div, table, td, th, tr } from "../../core/gui/dom";
+import { bind_attr, bind_children_to, div, table, td, th, tr } from "../../core/gui/dom";
 import { UnavailableView } from "./UnavailableView";
 import "./EntityInfoView.css";
 import { NumberInput } from "../../core/gui/NumberInput";
 import { rad_to_deg } from "../../core/math";
 import { EntityInfoController } from "../controllers/EntityInfoController";
 import { ResizableView } from "../../core/gui/ResizableView";
+import { QuestEntityPropModel } from "../model/QuestEntityPropModel";
+import { Disposable } from "../../core/observable/Disposable";
+import { Disposer } from "../../core/observable/Disposer";
+import { EntityPropType } from "../../core/data_formats/parsing/quest/properties";
 
 export class EntityInfoView extends ResizableView {
     readonly element = div({ className: "quest_editor_EntityInfoView", tabIndex: -1 });
 
     private readonly no_entity_view = new UnavailableView("No entity selected.");
 
-    private readonly table_element = table();
+    private readonly standard_props_element = table();
+    private readonly specific_props_element = table();
 
     private readonly type_element: HTMLTableCellElement;
     private readonly name_element: HTMLTableCellElement;
@@ -30,7 +35,7 @@ export class EntityInfoView extends ResizableView {
 
         const coord_class = "quest_editor_EntityInfoView_coord";
 
-        this.table_element.append(
+        this.standard_props_element.append(
             tr(th("Type:"), (this.type_element = td())),
             tr(th("Name:"), (this.name_element = td())),
             tr(th("Section:"), (this.section_id_element = td())),
@@ -45,12 +50,18 @@ export class EntityInfoView extends ResizableView {
             tr(th({ className: coord_class }, "Z:"), td(this.rot_z_element.element)),
         );
 
-        this.element.append(this.table_element, this.no_entity_view.element);
+        bind_children_to(this.specific_props_element, ctrl.props, this.create_prop_row);
+
+        this.element.append(
+            this.standard_props_element,
+            this.specific_props_element,
+            this.no_entity_view.element,
+        );
 
         this.element.addEventListener("focus", ctrl.focused, true);
 
         this.disposables(
-            bind_attr(this.table_element, "hidden", ctrl.unavailable),
+            bind_attr(this.standard_props_element, "hidden", ctrl.unavailable),
             this.no_entity_view.visible.bind_to(ctrl.unavailable),
 
             bind_attr(this.type_element, "textContent", ctrl.type),
@@ -102,4 +113,60 @@ export class EntityInfoView extends ResizableView {
         this.rot_y_element.enabled.val = enabled;
         this.rot_z_element.enabled.val = enabled;
     }
+
+    private create_prop_row(prop: QuestEntityPropModel): [HTMLTableRowElement, Disposable] {
+        const disposer = new Disposer();
+
+        let min: number | undefined;
+        let max: number | undefined;
+
+        switch (prop.type) {
+            case EntityPropType.U8:
+                min = 0;
+                max = 0xff;
+                break;
+            case EntityPropType.U16:
+                min = 0;
+                max = 0xffff;
+                break;
+            case EntityPropType.U32:
+                min = 0;
+                max = 0xffffffff;
+                break;
+            case EntityPropType.I8:
+                min = -0x80;
+                max = 0x7f;
+                break;
+            case EntityPropType.I16:
+                min = -0x8000;
+                max = 0x7fff;
+                break;
+            case EntityPropType.I32:
+                min = -0x80000000;
+                max = 0x7fffffff;
+                break;
+            case EntityPropType.Angle:
+                min = -2 * Math.PI;
+                max = 2 * Math.PI;
+                break;
+        }
+
+        const round_to =
+            prop.type === EntityPropType.F32 || prop.type === EntityPropType.Angle ? 3 : 1;
+
+        const value_input = disposer.add(
+            new NumberInput(prop.value.val, {
+                min,
+                max,
+                round_to,
+                enabled: false,
+            }),
+        );
+
+        disposer.add_all(value_input.value.bind_to(prop.value));
+
+        const element = tr(th(`${prop.name}:`), td(value_input.element));
+
+        return [element, disposer];
+    }
 }

src/quest_editor/model/QuestEntityModel.ts

@@ -1,6 +1,11 @@
-import { EntityType, QuestEntity } from "../../core/data_formats/parsing/quest/Quest";
+import {
+    entity_data,
+    EntityType,
+    get_entity_type,
+    QuestEntity,
+} from "../../core/data_formats/parsing/quest/Quest";
 import { Property } from "../../core/observable/property/Property";
-import { property } from "../../core/observable";
+import { list_property, property } from "../../core/observable";
 import { WritableProperty } from "../../core/observable/property/WritableProperty";
 import { SectionModel } from "./SectionModel";
 import { Euler, Quaternion, Vector3 } from "three";
@@ -8,6 +13,9 @@ import { floor_mod } from "../../core/math";
 import { euler, euler_from_quat } from "./euler";
 import { vec3_to_threejs } from "../../core/rendering/conversion";
 import { Vec3 } from "../../core/data_formats/vector";
+import { WritableListProperty } from "../../core/observable/property/list/WritableListProperty";
+import { QuestEntityPropModel } from "./QuestEntityPropModel";
+import { ListProperty } from "../../core/observable/property/list/ListProperty";
 
 // These quaternions are used as temporary variables to avoid memory allocation.
 const q1 = new Quaternion();
@@ -23,6 +31,7 @@ export abstract class QuestEntityModel<
     private readonly _world_position: WritableProperty<Vector3>;
     private readonly _rotation: WritableProperty<Euler>;
     private readonly _world_rotation: WritableProperty<Euler>;
+    private readonly _props: WritableListProperty<QuestEntityPropModel>;
 
     /**
      * Many modifications done to the underlying entity directly will not be reflected in this
@@ -54,6 +63,8 @@ export abstract class QuestEntityModel<
 
     readonly world_rotation: Property<Euler>;
 
+    readonly props: ListProperty<QuestEntityPropModel>;
+
     protected constructor(entity: Entity) {
         this.entity = entity;
 
@@ -78,6 +89,14 @@ export abstract class QuestEntityModel<
 
         this._world_rotation = property(rotation);
         this.world_rotation = this._world_rotation;
+
+        this._props = list_property(
+            undefined,
+            ...entity_data(get_entity_type(entity)).properties.map(
+                p => new QuestEntityPropModel(entity, p),
+            ),
+        );
+        this.props = this._props;
     }
 
     set_section(section: SectionModel): this {

src/quest_editor/model/QuestEntityPropModel.ts

@@ -0,0 +1,36 @@
+import { WritableProperty } from "../../core/observable/property/WritableProperty";
+import { Property } from "../../core/observable/property/Property";
+import { EntityProp, EntityPropType } from "../../core/data_formats/parsing/quest/properties";
+import { property } from "../../core/observable";
+import {
+    get_entity_prop_value,
+    QuestEntity,
+    set_entity_prop_value,
+} from "../../core/data_formats/parsing/quest/Quest";
+
+export class QuestEntityPropModel {
+    private readonly entity: QuestEntity;
+    private readonly prop: EntityProp;
+    private readonly _value: WritableProperty<number>;
+
+    readonly name: string;
+    readonly type: EntityPropType;
+    readonly value: Property<number>;
+
+    constructor(quest_entity: QuestEntity, entity_prop: EntityProp) {
+        this.entity = quest_entity;
+        this.prop = entity_prop;
+
+        this.name = entity_prop.name;
+
+        this.type = entity_prop.type;
+
+        this._value = property(get_entity_prop_value(quest_entity, entity_prop));
+        this.value = this._value;
+    }
+
+    set_value(value: number): void {
+        set_entity_prop_value(this.entity, this.prop, value);
+        this._value.val = value;
+    }
+}