@woosh/meep-engine 2.31.1 → 2.31.5

package/generation/example/generators/{mir_generator_place_buff_objects.js → interactive/mir_generator_place_buff_objects.js}

@@ -1,31 +1,32 @@
-import { CellMatcherGridPattern } from "../../rules/cell/CellMatcherGridPattern.js";
-import { matcher_tag_traversable_unoccupied } from "../rules/matcher_tag_traversable_unoccupied.js";
-import { CellMatcherNot } from "../../rules/logic/CellMatcherNot.js";
-import { CellMatcherContainsMarkerWithinRadius } from "../../rules/cell/CellMatcherContainsMarkerWithinRadius.js";
-import { GridCellActionPlaceTags } from "../../placement/action/GridCellActionPlaceTags.js";
-import { GridTags } from "../../GridTags.js";
-import { bitwiseAnd } from "../../../core/binary/operations/bitwiseAnd.js";
-import { GridCellActionPlaceMarker } from "../../markers/GridCellActionPlaceMarker.js";
-import { GridCellPlacementRule } from "../../placement/GridCellPlacementRule.js";
-import { GridTaskActionRuleSet } from "../../grid/generation/discrete/GridTaskCellActionRuleSet.js";
-import { GridActionRuleSet } from "../../markers/GridActionRuleSet.js";
-import { GridCellActionPlaceMarkerGroup } from "../../markers/GridCellActionPlaceMarkerGroup.js";
-import { matcher_tag_not_traversable } from "../rules/matcher_tag_not_traversable.js";
-import { MarkerNodeMatcherContainsTag } from "../../markers/matcher/MarkerNodeMatcherContainsTag.js";
-import { CellMatcherAnd } from "../../rules/logic/CellMatcherAnd.js";
-import { MarkerNodeMatcherByType } from "../../markers/matcher/MarkerNodeMatcherByType.js";
-import { CellMatcherOr } from "../../rules/logic/CellMatcherOr.js";
-import { RuleSelectionPolicyType } from "../../markers/RuleSelectionPolicyType.js";
-import { MarkerNodeMatcherAnd } from "../../markers/matcher/MarkerNodeMatcherAnd.js";
-import { MirGridLayers } from "../grid/MirGridLayers.js";
-import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLiteralFloat.js";
-import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
-import { GridPatternMatcherCell } from "../../rules/cell/GridPatternMatcherCell.js";
-import { BuffObjectTypes } from "../../../../../generator/BuffObjectTypes.js";
-import { UnlockableElementsManager } from "../../../../../model/unlocks/UnlockableElementsManager.js";
+import { CellMatcherGridPattern } from "../../../rules/cell/CellMatcherGridPattern.js";
+import { matcher_tag_traversable_unoccupied } from "../../rules/matcher_tag_traversable_unoccupied.js";
+import { CellMatcherNot } from "../../../rules/logic/CellMatcherNot.js";
+import { CellMatcherContainsMarkerWithinRadius } from "../../../rules/cell/CellMatcherContainsMarkerWithinRadius.js";
+import { GridCellActionPlaceTags } from "../../../placement/action/GridCellActionPlaceTags.js";
+import { GridTags } from "../../../GridTags.js";
+import { bitwiseAnd } from "../../../../core/binary/operations/bitwiseAnd.js";
+import { GridCellActionPlaceMarker } from "../../../markers/GridCellActionPlaceMarker.js";
+import { GridCellPlacementRule } from "../../../placement/GridCellPlacementRule.js";
+import { GridTaskActionRuleSet } from "../../../grid/generation/discrete/GridTaskCellActionRuleSet.js";
+import { GridActionRuleSet } from "../../../markers/GridActionRuleSet.js";
+import { GridCellActionPlaceMarkerGroup } from "../../../markers/GridCellActionPlaceMarkerGroup.js";
+import { matcher_tag_not_traversable } from "../../rules/matcher_tag_not_traversable.js";
+import { MarkerNodeMatcherContainsTag } from "../../../markers/matcher/MarkerNodeMatcherContainsTag.js";
+import { CellMatcherAnd } from "../../../rules/logic/CellMatcherAnd.js";
+import { MarkerNodeMatcherByType } from "../../../markers/matcher/MarkerNodeMatcherByType.js";
+import { CellMatcherOr } from "../../../rules/logic/CellMatcherOr.js";
+import { RuleSelectionPolicyType } from "../../../markers/RuleSelectionPolicyType.js";
+import { MarkerNodeMatcherAnd } from "../../../markers/matcher/MarkerNodeMatcherAnd.js";
+import { MirGridLayers } from "../../grid/MirGridLayers.js";
+import { CellFilterLiteralFloat } from "../../../filtering/numeric/CellFilterLiteralFloat.js";
+import { MirMarkerTypes } from "../../../../../generator/MirMarkerTypes.js";
+import { GridPatternMatcherCell } from "../../../rules/cell/GridPatternMatcherCell.js";
+import { BuffObjectTypes } from "../../../../../../generator/BuffObjectTypes.js";
+import { UnlockableElementsManager } from "../../../../../../model/unlocks/UnlockableElementsManager.js";
 
 const TAG_MAJOR = 'Major Buff';
 const TAG_MINOR = 'Minor Buff';
+const TAG_UTILITY = 'Utility Buff';
 
 
 const pMatcherNextToWall = new CellMatcherGridPattern();
@@ -60,6 +61,15 @@ const mNoMinorBuffObjectNearby = CellMatcherNot.from(
     )
 );
 
+const mNoUtilityBuffObjectNearby = CellMatcherNot.from(
+    CellMatcherContainsMarkerWithinRadius.from(
+        MarkerNodeMatcherAnd.from(
+            MarkerNodeMatcherContainsTag.from(MirMarkerTypes.BuffObject),
+            MarkerNodeMatcherContainsTag.from(TAG_MINOR)
+        ), 10
+    )
+);
+
 pMatcherNextToWall.addRule(0, 0, mNoBuffObjectsNearby);
 
 const placeTags = new GridCellActionPlaceTags();
@@ -91,7 +101,10 @@ const placeRoadMarkers = GridCellActionPlaceMarkerGroup.from([placeRoadConnector
 function makeMajorRule(tag) {
     return GridCellPlacementRule.from({
         matcher: CellMatcherAnd.from(
-            mNoMajorBuffObjectNearby,
+            CellMatcherAnd.from(
+                mNoMajorBuffObjectNearby,
+                mNoBuffObjectsNearby
+            ),
             CellMatcherAnd.from(
                 pMatcherNextToWall,
                 CellMatcherNot.from(
@@ -151,6 +164,40 @@ function makeMinorRule(tag) {
     });
 }
 
+/**
+ *
+ * @param {string} tag
+ * @param {number} [frequency]
+ * @return {GridCellPlacementRule}
+ */
+function makeUtilityRule(tag, frequency = 17) {
+    return GridCellPlacementRule.from({
+        matcher: CellMatcherAnd.from(
+            matcher_tag_traversable_unoccupied,
+
+            CellMatcherAnd.from(
+                mNoUtilityBuffObjectNearby,
+                CellMatcherNot.from(
+                    CellMatcherOr.from(
+                        mBuffObjectNearby,
+                        CellMatcherContainsMarkerWithinRadius.from(MarkerNodeMatcherByType.from(tag), frequency)
+                    )
+                )
+            )
+        ),
+        actions: [
+            placeTags,
+            clearTags,
+            GridCellActionPlaceMarker.from({
+                type: tag,
+                size: 0.52,
+                tags: [MirMarkerTypes.BuffObject, TAG_UTILITY]
+            })
+        ],
+        probability: CellFilterLiteralFloat.from(0.1)
+    });
+}
+
 /**
  * @param {Engine} engine
  * @returns {GridTaskActionRuleSet}
@@ -206,6 +253,25 @@ export const mir_generator_place_buff_objects = (engine) => {
     }
 
 
+    /**
+     *
+     * @param {string} id
+     * @param {string} type
+     * @param frequency
+     */
+    function attemptUtilityRule(id, type, frequency) {
+
+        plugin.runIfElementValue(
+            'object',
+            `buff/utility/${id}`,
+            true,
+            false,
+            () => {
+                rules.push(makeUtilityRule(type, frequency));
+            });
+    }
+
+
     if (plugin !== undefined) {
         attemptMajorRule(
             'increase_ability_power',
@@ -250,6 +316,11 @@ export const mir_generator_place_buff_objects = (engine) => {
             'campfire',
             BuffObjectTypes.Campfire
         );
+
+        // utility
+        attemptUtilityRule('resurrect', BuffObjectTypes.RESURRECT_ALL, 30);
+        attemptUtilityRule('heal_small', BuffObjectTypes.HEAL_SMALL, 17);
+
     }
 
 

package/generation/example/generators/mir_generator_place_starting_point.js

@@ -15,6 +15,7 @@ import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLitera
 import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
 import { MarkerNodeTransformerRemoveTag } from "../../markers/transform/MarkerNodeTransformerRemoveTag.js";
 import { MirMarkerTags } from "../../../../generator/MirMarkerTags.js";
+import { MarkerNodeTransformerSequence } from "../../markers/transform/MarkerNodeTransformerSequence.js";
 
 const MATCH_STARTING_POINT = CellMatcherLayerBitMaskTest.from(GridTags.StartingPoint, MirGridLayers.Tags);
 
@@ -23,18 +24,24 @@ const pattern = new CellMatcherGridPattern();
 
 pattern.addRule(0, 0, matcher_tag_traversable_unoccupied);
 pattern.addRule(0, 0, CellMatcherNot.from(MATCH_STARTING_POINT));
+// NEXT TO A BASE
 pattern.addRule(0, -1, CellMatcherLayerBitMaskTest.from(GridTags.Base, MirGridLayers.Tags));
 
 const rule = GridCellPlacementRule.from(
     {
-        matcher: pattern, actions: [
+        matcher: pattern,
+        actions: [
             GridCellActionPlaceTags.from(GridTags.StartingPoint | GridTags.Occupied, MirGridLayers.Tags),
             GridCellActionPlaceMarker.from({ type: MirMarkerTypes.StartingPoint }),
             // transfer ownership of any base within some distance to the player
-            GridCellActionTransformNearbyMarkers.from(5, MarkerNodeMatcherByType.from(MirMarkerTypes.Base), [
-                MarkerNodeTransformerRecordProperty.from('team', CellFilterLiteralFloat.from(0)),
-                MarkerNodeTransformerRemoveTag.from(MirMarkerTags.Encounter)
-            ])
+            GridCellActionTransformNearbyMarkers.from(
+                5,
+                MarkerNodeMatcherByType.from(MirMarkerTypes.Base),
+                MarkerNodeTransformerSequence.from([
+                    MarkerNodeTransformerRecordProperty.from('team', CellFilterLiteralFloat.from(0)),
+                    MarkerNodeTransformerRemoveTag.from(MirMarkerTags.Encounter)
+                ])
+            )
         ]
     }
 );

package/generation/example/grid/configureMirGrid.js

@@ -8,7 +8,7 @@ import { DataType } from "../../../core/collection/table/DataType.js";
  */
 export function configureMirGrid(data) {
 
-    data.addLayer(GridDataLayer.from(MirGridLayers.Tags, DataType.Uint32, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.Tags, DataType.Uint16, 1));
 
     data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromStart, DataType.Uint16, 1));
     data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromPlayArea, DataType.Uint16, 1));

package/generation/filtering/CellFilter.js

@@ -29,6 +29,20 @@ export class CellFilter {
         return this.__initialized;
     }
 
+    /**
+     *
+     * @param {GridData} grid
+     * @param {number} seed
+     */
+    ensureInitialized(grid, seed) {
+        if (!this.__initialized) {
+            this.initialize(grid, seed);
+
+            // make sure initialization flag is set
+            this.__initialized = true;
+        }
+    }
+
     /**
      *
      * @param {GridData} grid

package/generation/filtering/numeric/util/CellFilterLogToConsole.js

@@ -1,5 +1,6 @@
 import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../../../core/assert.js";
+
 
 export class CellFilterLogToConsole extends CellFilterUnaryOperation {
 

package/generation/grid/GridData.js

@@ -1,6 +1,9 @@
 import { assert } from "../../core/assert.js";
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
+import { MarkerMatchCounter } from "./MarkerMatchCounter.js";
+
+const scratch_match_counter = new MarkerMatchCounter();
 
 export class GridData {
     constructor() {
@@ -111,23 +114,24 @@ export class GridData {
      * @returns {boolean}
      */
     containsMarkerInCircle(x, y, radius, matcher) {
-        let result = false;
-        this.markers.traverseCircleIntersections(x, y, radius, data => {
-            /**
-             *
-             * @type {MarkerNode}
-             */
-            const marker = data.data;
+        return this.countMarkerInCircle(x, y, radius, matcher) > 0;
+    }
 
-            if (matcher.match(marker)) {
-                result = true;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} radius
+     * @param {MarkerNodeMatcher} matcher
+     * @returns {number}
+     */
+    countMarkerInCircle(x, y, radius, matcher) {
+        scratch_match_counter.matcher = matcher;
+        scratch_match_counter.count = 0;
 
-                //stop traversal
-                return false;
-            }
-        });
+        this.markers.traverseCircleIntersections(x, y, radius, scratch_match_counter.exec, scratch_match_counter);
 
-        return result;
+        return scratch_match_counter.count;
     }
 
     /**

package/generation/grid/MarkerMatchCounter.js

@@ -0,0 +1,23 @@
+export class MarkerMatchCounter {
+    /**
+     * @template T
+     */
+    constructor() {
+        /**
+         * Predicate
+         * @type {{match:function(T):boolean}|null}
+         */
+        this.matcher = null;
+        this.count = 0;
+    }
+
+    /**
+     *
+     * @param {QuadTreeDatum<T>} node
+     */
+    exec(node) {
+        if (this.matcher.match(node.data)) {
+            this.count++;
+        }
+    }
+}

package/generation/grid/generation/GridTaskApplyActionToCells.js

@@ -0,0 +1,86 @@
+import { GridTaskGenerator } from "../GridTaskGenerator.js";
+import { assert } from "../../../core/assert.js";
+import { actionTask } from "../../../core/process/task/TaskUtils.js";
+import TaskGroup from "../../../core/process/task/TaskGroup.js";
+import Task from "../../../core/process/task/Task.js";
+import TaskSignal from "../../../core/process/task/TaskSignal.js";
+
+export class GridTaskApplyActionToCells extends GridTaskGenerator {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {GridCellAction|null}
+         */
+        this.action = null;
+
+        /**
+         *
+         * @type {CellSupplier|null}
+         */
+        this.fitness = null;
+
+    }
+
+    /**
+     *
+     * @returns {GridTaskApplyActionToCells}
+     * @param {CellSupplier} selector
+     * @param {GridCellAction} action
+     * @param {string} name
+     */
+    static from({ selector, action, name }) {
+        assert.equal(selector.isCellSupplier, true, 'selector.isCellSupplier !== true');
+        assert.equal(action.isGridCellAction, true, 'action.isGridCellAction !== true');
+
+        const r = new GridTaskApplyActionToCells();
+
+        r.action = action;
+        r.fitness = selector;
+
+        return r;
+    }
+
+    build(grid, ecd, seed) {
+        const tInitialize = actionTask(() => {
+            this.fitness.initialize(grid, seed);
+            this.action.initialize(grid, seed);
+        });
+
+        let cursor = 0;
+
+        const tMain = new Task({
+            name: `Apply action to cells`,
+            computeProgress: () => {
+                const c = this.fitness.count();
+
+                if (c <= 0) {
+                    return 0;
+                }
+
+                return cursor / c;
+            },
+            cycleFunction: () => {
+                const cell_data = this.fitness.next();
+
+                if (cell_data === undefined) {
+                    return TaskSignal.EndSuccess;
+                }
+
+                cursor++;
+
+                const y = cell_data.y;
+                const x = cell_data.x;
+
+                this.action.execute(grid, x, y, cell_data.rotation);
+
+                return TaskSignal.Continue;
+            }
+        });
+
+        tMain.addDependency(tInitialize);
+
+        return new TaskGroup([tInitialize, tMain]);
+    }
+}

package/generation/grid/generation/grid/select/CellSupplier.js

@@ -0,0 +1,28 @@
+export class CellSupplier {
+    /**
+     *
+     * @param {GridData} grid
+     * @param {number} seed
+     */
+    initialize(grid, seed) {
+
+    }
+
+    /**
+     * next cell, or undefined if no more cells left
+     * @returns {{x:number, y:number, rotation:number} |undefined}
+     */
+    next() {
+        return undefined;
+    }
+
+    count() {
+        return -1;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+CellSupplier.prototype.isCellSupplier = true;

package/generation/grid/generation/grid/select/CellSupplierBestN.js

@@ -0,0 +1,188 @@
+import { CellSupplier } from "./CellSupplier.js";
+import { assert } from "../../../../../core/assert.js";
+import { CellMatcherAny } from "../../../../rules/CellMatcherAny.js";
+import { PI_HALF } from "../../../../../core/math/MathUtils.js";
+
+/**
+ *
+ * @param {{score:number}} a
+ * @param {{score:number}} b
+ * @returns {number}
+ */
+function byScore(a, b) {
+    return a.score - b.score;
+}
+
+/**
+ *
+ * @param {{index:number}} a
+ * @param {{index:number}} b
+ * @returns {number}
+ */
+function byIndex(a, b) {
+    return a.index - b.index;
+}
+
+export class CellSupplierBestN extends CellSupplier {
+    constructor() {
+        super();
+
+
+        /**
+         *
+         * @type {CellFilter|null}
+         */
+        this.fitness = null;
+        /**
+         *
+         * @type {number}
+         */
+        this.cursor = 0;
+        /**
+         *
+         * @type {{x:number, y:number, rotation:number}[]}
+         */
+        this.elements = [];
+
+        /**
+         *
+         * @type {CellMatcher|null}
+         */
+        this.predicate = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.limit = 0;
+
+        /**
+         *
+         * @type {boolean}
+         */
+        this.allow_rotation = false;
+    }
+
+    /**
+     * @param {CellFilter} fitness
+     * @param {CellMatcher} [predicate]
+     * @param {number} limit
+     * @param {boolean} allow_rotation
+     */
+    static from({
+                    fitness,
+                    predicate = CellMatcherAny.INSTANCE,
+                    limit = 1,
+                    allow_rotation = false
+                }) {
+        assert.isNumber(limit, 'limit');
+        assert.isNonNegativeInteger(limit, 'limit');
+        assert.equal(fitness.isCellFilter, true, 'fitness.isCellFilter !== true');
+        assert.equal(predicate.isCellMatcher, true, 'predicate.isCellMatcher !== true');
+        assert.isBoolean(allow_rotation, 'allow_rotation');
+
+        const r = new CellSupplierBestN();
+
+        r.fitness = fitness;
+        r.limit = limit;
+        r.predicate = predicate;
+        r.allow_rotation = allow_rotation;
+
+        return r;
+    }
+
+    initialize(grid, seed) {
+        super.initialize(grid, seed);
+
+        const predicate = this.predicate;
+        predicate.initialize(grid, seed);
+        this.fitness.ensureInitialized(grid, seed);
+
+        const fitness_scratch = [];
+
+        this.cursor = 0;
+
+        // build list
+        const h = grid.height;
+        const w = grid.width;
+
+        let rotation = 0;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                const cell_index = y * w + x;
+
+                if (predicate.match(grid, x, y, 0)) {
+                    rotation = 0;
+                } else if (this.allow_rotation) {
+                    if (predicate.match(grid, x, y, PI_HALF)) {
+                        rotation = PI_HALF;
+                    } else if (predicate.match(grid, x, y, PI_HALF * 2)) {
+                        rotation = PI_HALF * 2;
+                    } else if (predicate.match(grid, x, y, PI_HALF * 3)) {
+                        rotation = PI_HALF * 3;
+                    } else {
+                        // no rotated matches
+                        continue
+                    }
+
+                } else {
+                    continue;
+                }
+
+                const fitness = this.fitness.execute(grid, x, y, rotation);
+
+                if (fitness_scratch.length < this.limit) {
+                } else if (fitness_scratch[0].score < fitness) {
+                    // evict lower fitness candidate
+                    fitness_scratch.shift();
+                } else {
+                    continue;
+                }
+
+                fitness_scratch.push({
+                    score: fitness,
+                    index: cell_index,
+                    x,
+                    y,
+                    rotation: rotation
+                });
+
+                fitness_scratch.sort(byScore);
+
+            }
+        }
+
+        // sort elements by index for faster access
+        fitness_scratch.sort(byIndex);
+
+        // copy out the list
+        const found_cells = fitness_scratch.length;
+
+        this.elements = [];
+        for (let i = 0; i < found_cells; i++) {
+            const s = fitness_scratch[i];
+
+            this.elements[i] = {
+                x: s.x,
+                y: s.y,
+                rotation: s.rotation
+            };
+        }
+
+    }
+
+    next() {
+        const cursor = this.cursor;
+        const elements = this.elements;
+
+        if (cursor >= elements.length) {
+            return undefined;
+        }
+
+        const r = elements[cursor];
+
+        this.cursor++;
+
+        return r;
+    }
+}