@woosh/meep-engine 2.46.28 → 2.46.30

package/editor/view/ecs/components/sound/SoundEmitterController.js

@@ -0,0 +1,137 @@
+import View from "../../../../../src/view/View.js";
+import ObservedValue from "../../../../../src/core/model/ObservedValue.js";
+import DatGuiController from "../DatGuiController.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+import ButtonView from "../../../../../src/view/elements/button/ButtonView.js";
+import { NativeListController } from "../../../../../src/view/controller/controls/NativeListController.js";
+import {
+    SoundEmitterChannels,
+    SoundEmitterSystem
+} from "../../../../../src/engine/sound/ecs/emitter/SoundEmitterSystem.js";
+import { SoundTrack } from "../../../../../src/engine/sound/ecs/emitter/SoundTrack.js";
+import { SoundAttenuationFunction } from "../../../../../src/engine/sound/ecs/emitter/SoundAttenuationFunction.js";
+import { SoundEmitterFlags } from "../../../../../src/engine/sound/ecs/emitter/SoundEmitterFlags.js";
+
+class SoundTrackController extends EmptyView {
+    /**
+     *
+     * @param {SoundTrack} track
+     * @param engine
+     */
+    constructor(track, engine) {
+        super({ classList: ['sound-track-controller'] });
+
+        let audio = new Audio(track.url);
+
+        this.addChild(
+            new ButtonView({
+                name: 'play',
+                action() {
+
+                    //play the sound
+                    audio.play();
+
+                }
+            })
+        );
+
+
+        this.on.unlinked.add(() => {
+            audio.pause();
+        });
+
+        const dat = new DatGuiController();
+
+        dat.add(track, 'url').onChange((v) => {
+            audio.pause();
+
+            audio = new Audio(v);
+        });
+
+        if (track.channel === null) {
+            track.channel = "";
+        }
+
+        dat.add(track, 'loop');
+        dat.add(track, 'time');
+        dat.add(track, 'volume').step(0.001);
+        dat.add(track, 'startWhenReady');
+
+        this.addChild(dat);
+    }
+}
+
+export class SoundEmitterController extends View {
+    /**
+     *
+     * @param {Engine} engine
+     */
+    constructor(engine) {
+        super();
+
+        this.el = document.createElement('div');
+
+        this.addClass('ui-sound-emitter-controller');
+
+        this.model = new ObservedValue(null);
+
+        /**
+         *
+         * @param {SoundEmitter} soundEmitter
+         */
+        const update = soundEmitter => {
+            this.removeAllChildren();
+
+            const d = new DatGuiController();
+
+            if (soundEmitter.channel === null) {
+                soundEmitter.channel = SoundEmitterChannels.Effects;
+            }
+
+            const channel_enum = {};
+
+            /**
+             *
+             * @type {SoundEmitterSystem}
+             */
+            const soundEmitterSystem = engine.entityManager.getSystem(SoundEmitterSystem);
+
+            for (const channelName in soundEmitterSystem.channels) {
+                channel_enum[channelName] = channelName;
+            }
+
+            d.addEnumRaw(soundEmitter, 'channel', channel_enum);
+
+            d.add(soundEmitter, 'volume');
+
+            d.addControl(soundEmitter, 'distanceMin');
+            d.addControl(soundEmitter, 'distanceMax');
+
+            d.addEnumRaw(soundEmitter, 'attenuation', SoundAttenuationFunction);
+
+            d.addBitFlag(soundEmitter, 'flags', SoundEmitterFlags.Spatialization, 'spatialization');
+            d.addBitFlag(soundEmitter, 'flags', SoundEmitterFlags.Attenuation, 'attenuation');
+
+            this.addChild(d);
+
+            this.addChild(
+                new NativeListController({
+                    model: soundEmitter.tracks,
+                    classList: ['tracks'],
+                    elementFactory() {
+                        const track = new SoundTrack();
+
+                        track.url = "";
+
+                        return track;
+                    },
+                    elementViewFactory(track) {
+                        return new SoundTrackController(track, engine);
+                    }
+                })
+            );
+        };
+
+        this.model.onChanged.add(update);
+    }
+}

package/editor/view/ecs/components/story/StoryTriggerSetController.js

@@ -0,0 +1,214 @@
+import DatGuiController from "../DatGuiController.js";
+import { StoryTrigger } from "../../../../../../model/game/story/triggers/StoryTrigger.js";
+import { StoryActionType } from "../../../../../../model/game/story/action/StoryActionType.js";
+import ObservedValue from "../../../../../src/core/model/ObservedValue.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+import { StoryAction } from "../../../../../../model/game/story/action/StoryAction.js";
+import { NativeListController } from "../../../../../src/view/controller/controls/NativeListController.js";
+
+const storyActionControllerParamFactories = {
+    [StoryActionType.Delay]: {
+        duration: 1,
+    },
+    [StoryActionType.AddItem]: {
+        id: "",
+        count: 1
+    },
+    [StoryActionType.RemoveItem]: {
+        id: "",
+        count: 1
+    },
+    [StoryActionType.AddMoney]: {
+        amount: 0
+    },
+    [StoryActionType.RemoveMoney]: {
+        amount: 0
+    },
+    [StoryActionType.ShowStoryPage]: {
+        id: ""
+    },
+    [StoryActionType.IncrementVariable]: {
+        variable: ""
+    },
+    [StoryActionType.DecrementVariable]: {
+        variable: ""
+    },
+    [StoryActionType.SetBooleanVariable]: {
+        variable: "",
+        value: false
+    },
+    [StoryActionType.SetNumberVariable]: {
+        variable: "",
+        value: 0
+    },
+    [StoryActionType.CameraFocusEntity]: {
+        entity: 0,
+        distance: 40,
+        duration: 0
+    },
+    [StoryActionType.CameraFocusPoint]: {
+        x: 0,
+        y: 0,
+        distance: 0
+    },
+    [StoryActionType.UnitAdd]: {
+        id: "",
+        level: 1,
+        target: 0
+    },
+    [StoryActionType.ScenePush]: {
+        id: ""
+    },
+    [StoryActionType.SceneDestroy]: {
+        id: ""
+    },
+    [StoryActionType.FogRevealCircle]: {
+        x: 0,
+        y: 0,
+        radius: 0
+    },
+    [StoryActionType.FogConcealCircle]: {
+        x: 0,
+        y: 0,
+        radius: 0
+    },
+    [StoryActionType.GridPositionSet]: {
+        x: 0,
+        y: 0
+    },
+    [StoryActionType.ActionPointRemove]: {
+        value: 1
+    },
+    [StoryActionType.RotationEulerSetDegrees]: {
+        angleX: 0,
+        angleY: 0,
+        angleZ: 0,
+        ignoreX: false,
+        ignoreY: false,
+        ignoreZ: false,
+        duration: 0
+    },
+    [StoryActionType.Effect]: {
+        id: "",
+        parameters: ""
+    }
+};
+
+class StoryActionController extends DatGuiController {
+    /**
+     *
+     * @param {StoryAction} action
+     */
+    constructor(action) {
+        super();
+
+        this.addClass('story-action');
+
+
+        const control = this.addControl(action, 'type', StoryActionType);
+
+        //disable control
+        control.domElement.style.pointerEvents = "none";
+
+        //build parameters based on type
+        const params = storyActionControllerParamFactories[action.type];
+
+        const paramClone = Object.assign({}, params);
+
+        //merge default parameters with actual ones
+        const paramProxy = Object.assign({}, Object.assign(paramClone, action.parameters));
+
+        for (let propName in paramProxy) {
+            const parameterName = propName;
+            this.addControl(paramProxy, propName).onFinishChange(v => {
+                action.parameters[parameterName] = v;
+            });
+        }
+
+    }
+}
+
+class StoryTriggerController extends EmptyView {
+    /**
+     *
+     * @param {StoryTrigger} trigger
+     */
+    constructor(trigger) {
+        super({ classList: ['story-trigger'] });
+
+        const proxy = {
+            actionType: StoryActionType.Unknown,
+            active: trigger.active.getValue(),
+            addAction() {
+
+                const action = new StoryAction();
+
+                action.type = proxy.actionType;
+
+                trigger.actions.add(action);
+            }
+        };
+
+
+        const dat = new DatGuiController();
+        dat.addControl(trigger, "code").onFinishChange(() => trigger.compile());
+        dat.addControl(proxy, 'active').onChange(() => trigger.active.set(proxy.active));
+
+        dat.addControl(proxy, 'actionType', StoryActionType);
+        dat.addControl(proxy, 'addAction').name('+action');
+
+
+        this.addChild(dat);
+
+        this.addChild(new NativeListController({
+            model:trigger.actions,
+            classList: ["actions"],
+            elementFactory() {
+                return new StoryAction();
+            },
+            elementViewFactory(action){
+                return new StoryActionController(action);
+            }
+        }));
+    }
+}
+
+export class StoryTriggerSetController extends EmptyView {
+    /**
+     *
+     */
+    constructor() {
+        super({ classList: ['story-trigger-set-controller'] });
+
+        const model = new ObservedValue(null);
+
+        this.model = model;
+
+
+        this.model.onChanged.add((triggers) => {
+            this.removeAllChildren();
+
+
+            if (triggers !== null) {
+
+                /**
+                 * @type {List<StoryTrigger>}
+                 */
+                const list = triggers.elements;
+
+                const view = new NativeListController({
+                    model: list,
+                    elementFactory() {
+                        return new StoryTrigger();
+                    },
+                    elementViewFactory(trigger) {
+                        return new StoryTriggerController(trigger);
+                    },
+                    classList: ['triggers']
+                })
+
+                this.addChild(view);
+            }
+        });
+    }
+}

package/editor/view/ecs/components/unit/AuraController.js

@@ -0,0 +1,45 @@
+import View from "../../../../../src/view/View.js";
+import ImageView from "../../../../../src/view/elements/image/ImageView.js";
+import ButtonView from "../../../../../src/view/elements/button/ButtonView.js";
+import { LocalizedLabelView } from "../../../../../src/view/common/LocalizedLabelView.js";
+
+/**
+ * @extends {View}
+ */
+export class AuraController extends View {
+    /**
+     *
+     * @param {Aura} aura
+     * @param {function} requestRemoval
+     * @param {Localization} localization
+     */
+    constructor({ aura, requestRemoval, localization }) {
+        super();
+
+        this.model = aura;
+
+        this.el = document.createElement('div');
+        this.addClass('ui-aura-controller');
+
+        /**
+         *
+         * @type {AfflictionDescription}
+         */
+        const affliction = aura.affliction;
+
+        const iconView = new ImageView(affliction.icon);
+        iconView.addClass('icon');
+
+        this.addChild(iconView);
+
+        this.addChild(new ButtonView({ action: requestRemoval, name: '', classList: ['remove'] }));
+
+        const lName = new LocalizedLabelView({
+            id: affliction.getLocalizationIdForName(),
+            localization,
+            classList: ["name"]
+        });
+
+        this.addChild(lName);
+    }
+}

package/editor/view/library/MeshLibraryView.js

@@ -0,0 +1,164 @@
+import View from "../../../src/view/View.js";
+import { makeModelView } from "../../../src/view/renderModel.js";
+import Vector2 from "../../../src/core/geom/Vector2.js";
+import domify from "../../../src/view/DOM.js";
+import LabelView from "../../../src/view/common/LabelView.js";
+import List from "../../../src/core/collection/list/List.js";
+import AABB2 from "../../../src/core/geom/AABB2.js";
+import { DragEvents } from "../../../src/engine/input/devices/events/DragEvents.js";
+import { MouseEvents } from "../../../src/engine/input/devices/events/MouseEvents.js";
+import { TouchEvents } from "../../../src/engine/input/devices/events/TouchEvents.js";
+import { computePathBase } from "../../../src/core/path/computePathBase.js";
+
+
+const ICON_SIZE = 50;
+
+class MeshAssetView extends View {
+    /**
+     *
+     * @param {string} url
+     * @param {Promise.<AssetManager>} assetManager
+     * @param {Promise.<WebGLRenderer>} renderer
+     * @constructor
+     */
+    constructor({ url, assetManager, renderer }) {
+        super();
+
+        const $el = domify();
+
+        $el.addClass('ui-mesh-library-asset-view');
+
+        this.el = $el.el;
+
+        Promise.all([assetManager, renderer])
+            .then(function ([assetManager, renderer]) {
+                const imagePromise = makeModelView(url, assetManager, new Vector2(ICON_SIZE, ICON_SIZE), renderer, new AABB2(0, 0, 1, 1));
+
+                imagePromise.then(function (image) {
+                    $el.append(image);
+                });
+            });
+
+        const pathBase = computePathBase(url);
+
+        const lastIndexOfDot = pathBase.lastIndexOf('.');
+
+        let fileName;
+        if (lastIndexOfDot !== -1) {
+            fileName = pathBase.substring(0, lastIndexOfDot);
+        } else {
+            fileName = pathBase;
+        }
+
+        const vName = new LabelView(fileName);
+
+        this.addChild(vName);
+
+        $el.attr({ draggable: true });
+
+        $el.on(DragEvents.DragStart, function (event) {
+            console.log('dragstart', event);
+            event.stopPropagation();
+
+            event.dataTransfer.setData('text/json', JSON.stringify({
+                type: "Mesh",
+                url
+            }));
+        });
+
+        $el.on(MouseEvents.Down, function (event) {
+            event.stopPropagation();
+        });
+
+        $el.on(TouchEvents.Start, function (event) {
+            event.stopPropagation();
+        });
+
+        $el.on(MouseEvents.Move, function (event) {
+            event.stopPropagation();
+        });
+
+        $el.on(TouchEvents.Move, function (event) {
+            event.stopPropagation();
+        });
+    }
+}
+
+
+class MeshLibraryView extends View {
+    /**
+     *
+     * @param {MeshLibrary} library
+     * @param {Promise.<AssetManager>} assetManager
+     * @param {Promise.<WebGLRenderer>} renderer
+     * @constructor
+     */
+    constructor(library, assetManager, renderer) {
+        super();
+
+        const $el = domify();
+
+        $el.addClass('ui-mesh-library-view');
+
+        this.el = $el.el;
+
+        this.assets = new List();
+
+        const self = this;
+
+        function layout() {
+            const width = self.size.x;
+
+            const columnSpacing = 16;
+
+            const minRowSpacing = 8;
+
+            const rowLength = Math.floor(width / (ICON_SIZE + minRowSpacing));
+
+            const spareRowWidth = width - ICON_SIZE * rowLength;
+
+            const rowSpacing = spareRowWidth / Math.max(1, rowLength - 1);
+
+            const assets = self.assets;
+
+            const numAssets = assets.length;
+
+            let rowIndex = 0;
+            let columnIndex = 0;
+            for (let i = 0; i < numAssets; i++) {
+                const assetView = assets.get(i);
+
+                assetView.position.set(rowIndex * (ICON_SIZE + rowSpacing), columnIndex * (ICON_SIZE + columnSpacing));
+
+                rowIndex++;
+                if (rowIndex >= rowLength) {
+                    //start new row
+                    rowIndex = 0;
+                    columnIndex++;
+                }
+            }
+        }
+
+        function addAsset(url) {
+            const assetView = new MeshAssetView({ url, assetManager, renderer });
+
+            self.assets.add(assetView);
+
+            self.addChild(assetView);
+        }
+
+        library.assets.forEach(addAsset);
+        library.assets.on.added.add(addAsset);
+
+        this.layout = layout;
+
+        this.bindSignal(this.size.onChanged, layout);
+
+        this.on.linked.add(layout);
+    }
+}
+
+
+
+
+export default MeshLibraryView;