@woosh/meep-engine 2.46.28 → 2.46.30

package/editor/view/ecs/EntityList.js

@@ -0,0 +1,258 @@
+/**
+ * Created by Alex on 14/01/2017.
+ */
+
+
+import View from "../../../src/view/View.js";
+import dom from "../../../src/view/DOM.js";
+import LabelView from '../../../src/view/common/LabelView.js';
+import VirtualListView from '../../../src/view/common/VirtualListView.js';
+import ButtonView from '../../../src/view/elements/button/ButtonView.js';
+import ObservedValue from '../../../src/core/model/ObservedValue.js';
+import Signal from '../../../src/core/events/signal/Signal.js';
+import List from '../../../src/core/collection/list/List.js';
+import Tag from '../../../src/engine/ecs/components/Tag.js';
+
+import SelectionAddAction from '../../actions/concrete/SelectionAddAction.js';
+import SelectionRemoveAction from '../../actions/concrete/SelectionRemoveAction.js';
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+
+class EntityView extends View {
+    /**
+     *
+     * @param entity
+     * @param {EntityComponentDataset} entityDataset
+     * @constructor
+     */
+    constructor(entity, entityDataset) {
+        super(entity, entityDataset);
+
+        const dRoot = dom('div');
+
+        dRoot.addClass('entity-view');
+
+        this.el = dRoot.el;
+        const self = this;
+
+        this.model = entity;
+
+        const lId = new LabelView(entity, { classList: ['id'] });
+        lId.position.setX(0);
+        this.addChild(lId);
+
+        this.isSelected = new ObservedValue(false);
+
+        const dCheckBox = dom('div');
+        dCheckBox.addClass('selection');
+
+        this.isSelected.onChanged.add(function (v) {
+            dCheckBox.setClass('selected', v);
+        });
+
+        if (this.on === undefined) {
+            this.on = {};
+        }
+
+        const signals = this.on;
+
+        signals.selected = new Signal();
+
+        dCheckBox.on('click', function () {
+            signals.selected.dispatch();
+        });
+
+        //add tag text
+        const tag = entityDataset.getComponent(entity, Tag);
+        if (tag !== undefined) {
+            const vTags = new EmptyView({ classList: ['tag-container'] });
+
+            this.addChild(vTags);
+
+            tag.traverse(n => {
+
+                const lTag = new LabelView(n, {
+                    classList: ['tag']
+                });
+
+                vTags.addChild(lTag);
+            });
+        }
+        this.el.appendChild(dCheckBox.el);
+    }
+}
+
+
+class EntityListView extends View {
+    constructor(editor) {
+        super(editor);
+
+        const dRoot = dom('div');
+        dRoot.addClass('entity-list-view');
+
+        this.el = dRoot.el;
+
+        if (this.on === undefined) {
+            this.on = {};
+        }
+
+        this.on.interaction = new Signal();
+
+        const hiddenEntities = new List();
+
+        const self = this;
+        this.editor = editor;
+
+        function makeElement(entity) {
+            const entityManager = editor.engine.entityManager;
+            const entityDataset = entityManager.dataset;
+
+            const entityView = new EntityView(entity, entityDataset);
+            if (editor.selection.contains(entity)) {
+                entityView.isSelected.set(true);
+            }
+            entityView.on.selected.add(function () {
+                const actions = self.editor.actions;
+                actions.mark();
+                const value = !entityView.isSelected.get();
+                if (value) {
+                    actions.do(new SelectionAddAction([entity]));
+                } else {
+                    actions.do(new SelectionRemoveAction([entity]));
+                }
+            });
+
+            entityView.el.addEventListener('click', function () {
+                self.on.interaction.dispatch(entity);
+            });
+
+            return entityView;
+        }
+
+        const entityList = new List();
+
+
+        const list = new VirtualListView(entityList, {
+            lineSize: 20,
+            elementFactory: makeElement
+        });
+
+        list.size.set(150, 600);
+
+        const actionAdd = {
+            name: "Add",
+            action: function () {
+                engine.entityManager.createEntity();
+            }
+        };
+
+        const vAddButton = new ButtonView(actionAdd);
+        vAddButton.size.set(100, 20);
+
+        this.addChildAt(list, 0, 0, 0, 0);
+        this.addChildAt(vAddButton, 0, 1, 0, 0);
+
+
+        function addOne(entity) {
+            //exclude editor-owned entities
+            if (editor.isEditorEntity(entity)) {
+                hiddenEntities.add(entity);
+
+            } else {
+                entityList.add(entity);
+            }
+        }
+
+        function removeOne(entity) {
+            const hiddenIndex = hiddenEntities.indexOf(entity);
+            if (hiddenIndex !== -1) {
+                hiddenEntities.remove(hiddenIndex);
+            } else {
+                entityList.removeOneOf(entity);
+            }
+        }
+
+        function selectOne(entity) {
+            list.renderedViews.forEach(function (v) {
+                if (v.model === entity) {
+                    v.isSelected.set(true);
+                }
+            });
+        }
+
+        function deselectOne(entity) {
+            list.renderedViews.forEach(function (v) {
+                if (v.model === entity) {
+                    v.isSelected.set(false);
+                }
+            });
+        }
+
+        this.handlers = {
+            addOne: addOne,
+            removeOne: removeOne,
+            selectOne: selectOne,
+            deselectOne: deselectOne,
+            reset: function () {
+                //reset all
+                entityList.reset();
+                hiddenEntities.reset();
+            }
+        };
+
+
+        const handlers = this.handlers;
+
+        //listen for selection
+        this.bindSignal(editor.selection.on.added, handlers.selectOne);
+        this.bindSignal(editor.selection.on.removed, handlers.deselectOne);
+        this.size.onChanged.add(function (x, y) {
+            list.size.set(x, y);
+        });
+    }
+
+    layout() {
+
+    }
+
+    link() {
+        super.link();
+
+        const entityManager = this.editor.engine.entityManager;
+
+        const handlers = this.handlers;
+
+        //list all active
+        const dataset = entityManager.dataset;
+        dataset.traverseEntityIndices(function (id) {
+            handlers.addOne(id);
+        });
+
+        //propagate current selection
+        this.editor.selection.forEach(handlers.selectOne);
+
+
+        dataset.onEntityCreated.add(handlers.addOne);
+        dataset.onEntityRemoved.add(handlers.removeOne);
+        entityManager.on.reset.add(handlers.reset);
+
+    }
+
+    unlink() {
+        super.unlink();
+
+        const entityManager = this.editor.engine.entityManager;
+        const dataset = entityManager.dataset;
+
+        const handlers = this.handlers;
+
+        //clear out entity list
+        this.handlers.reset();
+
+        dataset.onEntityCreated.remove(handlers.addOne);
+        dataset.onEntityRemoved.remove(handlers.removeOne);
+        entityManager.on.reset.remove(handlers.reset);
+    }
+}
+
+
+export default EntityListView;

package/editor/view/ecs/components/BlackboardController.js

@@ -0,0 +1,50 @@
+import DatGuiController from "./DatGuiController.js";
+import { clear } from "../../../../src/view/controller/dat/DatGuiUtils.js";
+
+export class BlackboardController extends DatGuiController {
+    constructor() {
+        super();
+
+        this.addClass('ui-component-controller-blackboard');
+
+        const self = this;
+
+        /**
+         *
+         * @param {Blackboard} model
+         */
+        function setModel(model) {
+            const gui = self.gui;
+            clear(gui);
+
+            if (model !== null) {
+
+                const data = model.data;
+
+                const elements = [];
+
+                for (let p in data) {
+                    const datum = data[p];
+
+                    elements.push({
+                        datum,
+                        name: p
+                    });
+
+                }
+
+                elements.sort((a, b) => a.name.localeCompare(b.name));
+
+                const n = elements.length;
+                for (let i = 0; i < n; i++) {
+                    const element = elements[i];
+
+
+                    self.add(element.datum, 'value').name(element.name);
+                }
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}

package/editor/view/ecs/components/DatGuiController.js

@@ -0,0 +1,216 @@
+import GuiControl from "../../../../src/view/controller/controls/GuiControl.js";
+import dat from "dat.gui";
+
+class DatGuiController extends GuiControl {
+    constructor({ classList = [] } = {}) {
+        super();
+
+        const gui = new dat.GUI({
+            autoPlace: false,
+            closed: false,
+            closeOnTop: false, //If true, close/open button shows on top of the GUI
+            resizable: false
+        });
+
+        this.gui = gui;
+
+        const domElement = gui.domElement;
+        this.el = domElement;
+        this.dRoot.el = domElement;
+
+        this.dRoot.addClass(GuiControl.CSS_CLASS_NAME);
+
+
+        classList.forEach(c => this.addClass(c));
+    }
+
+    /**
+     *
+     * @param {object} object
+     * @param {string} property
+     * @param {number} bitIndex
+     * @param {string} name
+     * @param {*} [extra]
+     */
+    addBitFlag(object, property, bitIndex, name, extra) {
+
+        const proxy = {
+            get v() {
+                return (object[property] & bitIndex) !== 0;
+            },
+
+            set v(v) {
+                if (v) {
+                    object[property] |= bitIndex;
+                } else {
+                    object[property] &= ~bitIndex;
+                }
+            }
+        };
+
+        const c = this.addControl(proxy, 'v');
+
+        c
+            .name(name);
+
+        return c;
+    }
+
+    /**
+     *
+     * @param {function} method
+     * @param {string} [name]
+     * @param {*} [thisArg]
+     * @return {Controller}
+     */
+    addAction(method, name, thisArg) {
+        if (name === undefined) {
+            name = method.name;
+        }
+
+        const proxy = {
+            m: () => {
+                method.call(thisArg);
+            }
+        };
+
+        return this.add(proxy, 'm').name(name);
+    }
+
+    /**
+     *
+     * @param object
+     * @param {string}  property
+     * @param extra
+     * @return {Controller}
+     */
+    add(object, property, extra) {
+        const prop = object[property];
+
+        if (prop === undefined) {
+            throw new Error(`Property '${property}' is undefined`);
+        }
+
+        if (prop === null) {
+            throw new Error(`Property '${property}' is null`);
+        }
+
+        let c;
+
+        if (prop.isObservedBoolean || prop.isObservedInteger || prop.isVector1 || prop.isObservedString) {
+
+            const proxy = { v: prop.getValue() };
+
+            c = this.addControl(proxy, 'v');
+
+            c
+                .name(property)
+                .onChange(v => prop.set(v));
+
+            this.bindSignal(prop.onChanged, v => {
+                proxy.v = v;
+                c.setValue(v);
+            });
+
+        } else if (prop.isVector2 || prop.isVector3) {
+
+            const proxy = {
+                get x() {
+                    return prop.x;
+                },
+                set x(v) {
+                    prop.setX(v);
+                },
+                get y() {
+                    return prop.y;
+                },
+                set y(v) {
+                    prop.setY(v);
+                },
+                get z() {
+                    return prop.z;
+                },
+                set z(v) {
+                    prop.setZ(v);
+                }
+            };
+
+            const f = this.addFolder(property);
+
+            let step = 0.00001;
+
+            if (extra !== undefined && extra.step !== undefined) {
+                step = extra.step;
+            }
+
+
+            f.add(proxy, 'x').step(step);
+            f.add(proxy, 'y').step(step);
+
+            if (prop.isVector3) {
+                f.add(proxy, 'z').step(step);
+            }
+
+            c = f;
+        } else {
+            c = this.addControl(object, property, extra);
+        }
+
+        return c;
+    }
+
+    addEnumRaw(object, property, type) {
+
+        const proxy = { v: object[property] };
+
+        const c = this.addControl(proxy, "v", type);
+
+        c.name(property);
+        c.onChange(v => {
+            for (let typeKey in type) {
+                const typeValue = type[typeKey];
+                if (typeValue == v) {
+                    object[property] = typeValue;
+                    return;
+                }
+            }
+
+            console.warn(`Value ${v} not found in enum`, v, type);
+        });
+
+        return c;
+    }
+
+    /**
+     *
+     * @param {Object} object
+     * @param {string} property
+     * @param {Object|Array} [extra]
+     * @returns {Controller}
+     */
+    addControl(object, property, extra) {
+        if (object[property] === undefined) {
+            throw new Error(`Object has no property '${property}'`);
+        }
+
+        const control = this.gui.add(object, property, extra);
+
+        return control;
+    }
+
+    addFolder(name) {
+        const control = this.gui.addFolder(name);
+
+
+        return control;
+    }
+
+    addColorControl(object, property) {
+        const control = this.gui.addColor(object, property);
+
+        return control;
+    }
+}
+
+
+export default DatGuiController;

package/editor/view/ecs/components/FogOfWarController.js

@@ -0,0 +1,78 @@
+import DatGuiController from "./DatGuiController.js";
+import { clear } from "../../../../src/view/controller/dat/DatGuiUtils.js";
+import ButtonView from "../../../../src/view/elements/button/ButtonView.js";
+import { FogOfWarRevealerSystem } from "../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js";
+
+export class FogOfWarController extends DatGuiController {
+    /**
+     * @param {EntityManager} em
+     * @constructor
+     */
+    constructor(em) {
+        super();
+
+        const self = this;
+
+        this.addChild(new ButtonView({
+            action() {
+                /**
+                 *
+                 * @type {FogOfWar}
+                 */
+                const fow = self.model.getValue();
+
+                fow.clear();
+
+                /**
+                 *
+                 * @type {FogOfWarRevealerSystem}
+                 */
+                const revealerSystem = em.getSystem(FogOfWarRevealerSystem);
+
+                if (revealerSystem !== null) {
+                    revealerSystem.forceUpdate();
+                }
+            },
+            name: 'Conceal All'
+        }));
+
+        this.addChild(new ButtonView({
+            action() {
+                /**
+                 *
+                 * @type {FogOfWar}
+                 */
+                const fow = self.model.getValue();
+
+                fow.revealAll();
+
+                /**
+                 *
+                 * @type {FogOfWarRevealerSystem}
+                 */
+                const revealerSystem = em.getSystem(FogOfWarRevealerSystem);
+
+                if (revealerSystem !== null) {
+                    revealerSystem.forceUpdate();
+                }
+            },
+            name: 'Reveal All'
+        }));
+
+        /**
+         *
+         * @param {FogOfWar} model
+         */
+        function setModel(model) {
+            const gui = self.gui;
+            clear(gui);
+
+            if (model !== null) {
+
+
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}

package/editor/view/ecs/components/FogOfWarRevealerController.js

@@ -0,0 +1,44 @@
+import { LineView } from "./common/LineView.js";
+import LabelView from "../../../../src/view/common/LabelView.js";
+import View from "../../../../src/view/View.js";
+import ObservedValue from "../../../../src/core/model/ObservedValue.js";
+import Vector1Control from "../../../../src/view/controller/controls/Vector1Control.js";
+
+export class FogOfWarRevealerController extends View {
+    /**
+     *
+     * @constructor
+     */
+    constructor() {
+        super();
+
+        this.el = document.createElement('div');
+        this.addClass('ui-fow-revealer-controller');
+
+        this.model = new ObservedValue(null);
+
+        const cRadius = new Vector1Control();
+
+        this.addChild(new LineView({
+            elements: [
+                new LabelView('radius'),
+                cRadius
+            ]
+        }));
+
+        /**
+         *
+         * @param {FogOfWarRevealer} model
+         */
+        function setModel(model) {
+
+            if (model !== null) {
+                cRadius.model.set(model.radius);
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}
+
+

package/editor/view/ecs/components/GeneratedArmyController.js

@@ -0,0 +1,42 @@
+import DatGuiController from "./DatGuiController.js";
+import { clear } from "../../../../src/view/controller/dat/DatGuiUtils.js";
+import { buildCombatUnitsValidator } from "../../../../../model/game/ecs/component/generator/army/GeneratedArmy.js";
+import { extractFunctionBody } from "../../../../src/core/function/extractFunctionBody.js";
+
+export class GeneratedArmyController extends DatGuiController {
+    /**
+     *
+     * @constructor
+     */
+    constructor() {
+        super();
+
+        const self = this;
+
+        const proxy = {
+            validator: ''
+        };
+
+
+        /**
+         *
+         * @param {GeneratedArmy} model
+         */
+        function setModel(model) {
+            const gui = self.gui;
+            clear(gui);
+
+            if (model !== null) {
+                proxy.validator = extractFunctionBody(model.validator);
+
+                self.addControl(model, 'value').name('Value');
+
+                self.addControl(proxy, 'validator').name('Validator').onChange(function () {
+                    model.validator = buildCombatUnitsValidator(proxy.validator);
+                });
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}