@woosh/meep-engine 2.33.65 → 2.33.70

package/generation/example/SampleGenerator0.js

@@ -21,7 +21,6 @@ import { matcher_tag_traversable } from "./rules/matcher_tag_traversable.js";
 import { GridTaskGenerateRoads } from "../grid/generation/road/GridTaskGenerateRoads.js";
 import { mir_generator_place_road_decorators } from "./generators/mir_generator_place_road_decorators.js";
 import { MarkerNodeMatcherByType } from "../markers/matcher/MarkerNodeMatcherByType.js";
-import { mir_generator_place_buff_objects } from "./generators/interactive/mir_generator_place_buff_objects.js";
 import { GridTaskDensityMarkerDistribution } from "../grid/generation/GridTaskDensityMarkerDistribution.js";
 import { CellFilterSimplexNoise } from "../filtering/numeric/complex/CellFilterSimplexNoise.js";
 import { NumericInterval } from "../../core/math/interval/NumericInterval.js";
@@ -211,12 +210,11 @@ const prEnemyCorridorGuard = GridCellPlacementRule.from(
         ), actions: [
             ACTION_PLACE_ENEMY_MARKER,
             ACTION_PLACE_ENEMY_TAG
-        ]
+        ],
+        probability: CellFilterLiteralFloat.from(0.5)
     }
 );
 
-prEnemyCorridorGuard.probability = 0.5;
-
 const gRuleSet2 = GridTaskActionRuleSet.from({ rules: GridActionRuleSet.from({ rules: [prEnemyTreasureGuard, prEnemyCorridorGuard] }) });
 
 gRuleSet2.addDependency(gRuleSetTreasureGuards);
@@ -226,7 +224,11 @@ const gPlaceStartingPoint = mir_generator_place_starting_point();
 
 gPlaceStartingPoint.addDependency(gConnectRooms);
 
-const gBuildDistanceMap = GridTaskBuildSourceDistanceMap.from({ source: MATCH_STARTING_POINT, pass: MATCH_EMPTY });
+const gBuildDistanceMap = GridTaskBuildSourceDistanceMap.from({
+    source: MATCH_STARTING_POINT,
+    pass: MATCH_EMPTY,
+    layer: MirGridLayers.DistanceFromStart
+});
 
 gBuildDistanceMap.addDependency(gPlaceStartingPoint);
 
@@ -235,11 +237,8 @@ gRuleSet1.addDependency(gBuildDistanceMap);
 const gBases = mir_generator_place_bases();
 gBases.addDependency(gMakeEmpty);
 
-const gBuffObjects = mir_generator_place_buff_objects();
-gBuffObjects.addDependency(gBases);
 
 gConnectRooms.addDependency(gBases);
-gConnectRooms.addDependency(gBuffObjects);
 
 gPlaceStartingPoint.addDependency(gBases);
 
@@ -250,7 +249,6 @@ const gRoads = new GridTaskGenerateRoads();
 
 gRoads.addDependency(gConnectRooms);
 gRoads.addDependency(gBases);
-gRoads.addDependency(gBuffObjects);
 
 const gRoadDecorators = mir_generator_place_road_decorators();
 
@@ -540,7 +538,6 @@ gFoliageLarge.addDependencies([
     gRuleSet1,
     gRuleSet2,
     gRuleSetTreasureGuards,
-    gBuffObjects,
     gBases
 ]);
 
@@ -555,7 +552,6 @@ SampleGenerator0.addGenerator(gConnectRooms);
 SampleGenerator0.addGenerator(gRoads);
 SampleGenerator0.addGenerator(gRoadDecorators);
 SampleGenerator0.addGenerator(gBases);
-SampleGenerator0.addGenerator(gBuffObjects);
 SampleGenerator0.addGenerator(gPlaceStartingPoint);
 SampleGenerator0.addGenerator(gBuildDistanceMap);
 SampleGenerator0.addGenerator(gRuleSet1);

package/generation/example/filters/SampleGroundMoistureFilter.js

@@ -24,7 +24,8 @@ export const SampleGroundMoistureFilter = CellFilterAdd.from(
                 CellFilterStep.from(CellFilterLiteralFloat.from(0), fReadHeight)
             ),
             7,
-            7
+            7,
+            1
         ),
         CellFilterLiteralFloat.from(0.6)
     )

package/generation/example/main.js

@@ -0,0 +1,215 @@
+import { EngineHarness } from "../../engine/EngineHarness.js";
+import RenderSystem from "../../engine/ecs/systems/RenderSystem.js";
+import { Camera } from "../../engine/graphics/ecs/camera/Camera.js";
+import TopDownCameraController from "../../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import { TopDownCameraLander } from "../../engine/graphics/ecs/camera/topdown/TopDownCameraLander.js";
+import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
+import { TerrainFlags } from "../../engine/ecs/terrain/ecs/TerrainFlags.js";
+import Water from "../../engine/graphics/ecs/water/Water.js";
+import GridObstacle from "../../engine/grid/components/GridObstacle.js";
+import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
+import GridPosition from "../../engine/grid/components/GridPosition.js";
+import { Transform } from "../../engine/ecs/transform/Transform.js";
+import { GridData } from "../grid/GridData.js";
+import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+import { ThemeEngine } from "../theme/ThemeEngine.js";
+import { AreaTheme } from "../theme/AreaTheme.js";
+import TaskGroup from "../../core/process/task/TaskGroup.js";
+import { actionTask } from "../../core/process/task/TaskUtils.js";
+import { generateTerrainPreview } from "../../../../generator/generator/generateTerrainPreview.js";
+import { SampleTheme0 } from "./themes/SampleTheme0.js";
+import { SampleGenerator0 } from "./SampleGenerator0.js";
+import { configureMirGrid } from "./grid/configureMirGrid.js";
+import { EngineConfiguration } from "../../engine/EngineConfiguration.js";
+import TerrainSystem from "../../engine/ecs/terrain/ecs/TerrainSystem.js";
+import WaterSystem from "../../engine/graphics/ecs/water/WaterSystem.js";
+import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
+import TopDownCameraControllerSystem from "../../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { TopDownCameraLanderSystem } from "../../engine/graphics/ecs/camera/topdown/TopDownCameraLanderSystem.js";
+import LightSystem from "../../engine/graphics/ecs/light/LightSystem.js";
+
+function makeEngineConfig(engine) {
+    const config = new EngineConfiguration();
+
+    const graphics = engine.graphics;
+
+    config.addSystem(new RenderSystem(graphics));
+    config.addSystem(new TerrainSystem(graphics, engine.assetManager));
+    config.addSystem(new WaterSystem(graphics));
+    config.addSystem(new MeshSystem(engine));
+    config.addSystem(new TopDownCameraControllerSystem());
+    config.addSystem(new TopDownCameraLanderSystem());
+    config.addSystem(new LightSystem(engine))
+
+    return config;
+}
+
+
+/**
+ *
+ * @param {EngineHarness} harness
+ * @return {Promise<void>}
+ */
+async function init(harness) {
+    const engine = harness.engine;
+
+    await makeEngineConfig(engine).apply(engine);
+
+    await harness.initialize();
+
+    main(engine);
+}
+
+function prepare_gen_task({
+                              SIZE_X = 64,
+                              SIZE_Y = 64,
+                              ecd
+                          }) {
+
+    const camera = EngineHarness.buildCamera({
+        engine,
+        target: new Vector3(15, 0, 16),
+        // pitch: -PI_HALF,
+        pitch: 1.1,
+        yaw: 3.14,
+        distance: 13,
+        ecd,
+        distanceMin: 5,
+        distanceMax: 30
+    });
+
+    camera.add(new TopDownCameraLander());
+
+    // build lights
+    EngineHarness.buildLights({ engine })
+
+
+    // build terrain
+    const terrain = new Terrain();
+
+    terrain.resolution = 4;
+
+    terrain.size.set(SIZE_X, SIZE_Y);
+    terrain.samplerHeight.resize(SIZE_X, SIZE_Y);
+    terrain.splat.resize(SIZE_X * 4, SIZE_Y * 4, 0);
+
+    terrain.layers.resolution.set(512, 512);
+
+    terrain.clearFlag(TerrainFlags.Built);
+    terrain.build(engine.assetManager);
+
+    const water = new Water();
+
+    water.color.setRGB(0.2, 0.0, 0.5);
+    water.shoreColor.setRGB(0.3, 0.3, 1);
+    water.shoreDepthTransition.set(0.16, 0.5);
+    water.waveFrequency.set(1.3);
+    water.waveAmplitude.set(0.15);
+    water.waveSpeed.set(1.2);
+    water.scattering.set(1.2);
+    water.level.set(-0.3);
+
+    const obstacle = new GridObstacle();
+    obstacle.resize(terrain.size.x, terrain.size.y);
+
+    const terrainBuilder = new EntityBuilder();
+
+    terrainBuilder
+        .add(terrain)
+        .add(water)
+        .add(obstacle)
+        .add(new GridPosition())
+        .add(new Transform())
+        .build(ecd);
+
+
+    const gridData = new GridData();
+
+    configureMirGrid(gridData);
+
+    gridData.resize(terrain.size.x, terrain.size.y);
+    gridData.computeScale(1);
+
+    const generator = SampleGenerator0;
+
+    const tGenerationTask = generator.generate(ecd, gridData, computeStringHash('alexx855'));
+
+
+    const themeEngine = new ThemeEngine();
+    themeEngine.assetManager = engine.assetManager;
+
+    const theme0 = new AreaTheme();
+
+    const width = gridData.width;
+    const height = gridData.height;
+
+    theme0.mask.resize(width, height);
+    theme0.mask.mask.fill(0, 0, width, height, [1]);
+    theme0.theme = SampleTheme0;
+
+    themeEngine.add(theme0);
+
+
+    themeEngine.random.setCurrentSeed(1);
+    const tTheme = themeEngine.apply(gridData, ecd);
+
+    tTheme.addDependency(tGenerationTask);
+
+
+    const tBuildLevel = new TaskGroup([tGenerationTask, tTheme]);
+
+
+    const tAddGameplayElements = actionTask(() => {
+        // prepare gameplay-specific things on top of the generated level
+
+        //build minimap
+        const terrainPreview = generateTerrainPreview(terrainBuilder.entity, ecd);
+        terrain.preview.copy(terrainPreview);
+    });
+
+    tAddGameplayElements.addDependency(tBuildLevel);
+
+    return new TaskGroup([tBuildLevel, tAddGameplayElements]);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function main(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const tBuildLevel = prepare_gen_task({ ecd });
+
+    engine.loadSlowTask(tBuildLevel);
+
+    engine.executor.runGroup(tBuildLevel);
+
+    tBuildLevel.promise().then(() => {
+        console.log('Generation took ', tBuildLevel.getExecutedCpuTime(), 'ms');
+
+        const camera = ecd.getAnyComponent(Camera);
+
+        EngineHarness.buildOrbitalCameraController({
+            cameraEntity: camera.entity,
+            engine
+        });
+
+        // tweak camera for prototyping
+        const ctrl = ecd.getComponent(camera.entity, TopDownCameraController);
+        if (ctrl !== undefined) {
+            ctrl.distanceMax = 200;
+        }
+
+    });
+
+    // Resume audio context
+    engine.devices.pointer.on.down.addOne(engine.sound.resumeContext, engine.sound);
+    engine.devices.pointer.on.wheel.addOne(engine.sound.resumeContext, engine.sound);
+
+}
+
+const engineHarness = new EngineHarness();
+
+init(engineHarness);

package/generation/example/themes/SampleTheme0.js

@@ -46,6 +46,8 @@ import { SoundEmitter } from "../../../engine/sound/ecs/emitter/SoundEmitter.js"
 import { SampleGroundMoistureFilter } from "../filters/SampleGroundMoistureFilter.js";
 import GeneratedArmy from "../../../../model/game/ecs/component/generator/army/GeneratedArmy.js";
 import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
+import { TerrainLayerDescription } from "../../theme/TerrainLayerDescription.js";
+import Vector2 from "../../../core/geom/Vector2.js";
 
 export const SampleTheme0 = new Theme();
 
@@ -123,10 +125,6 @@ const filterSand = CellFilterMultiply.from(
     filterNotRockAndNotRoad
 );
 
-const TERRAIN_LAYER_GRASS = 0;
-const TERRAIN_LAYER_ROCK = 1;
-const TERRAIN_LAYER_SAND = 3;
-
 terrainTheme.rules.push(TerrainLayerRule.from(
     CellFilterMultiply.from(
         CellFilterMultiply.from(
@@ -135,22 +133,34 @@ terrainTheme.rules.push(TerrainLayerRule.from(
         ),
         filterNotRockAndNotRoad
     ),
-    TERRAIN_LAYER_GRASS
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/materials/Sci-Fi Planet/Grass_02.png',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterRock,
-    TERRAIN_LAYER_ROCK
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_04_Rocks/Stylized_04_Rocks_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterSand,
-    TERRAIN_LAYER_SAND
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_06_Sand/Stylized_06_Sand_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
     filterRoad,
-    2,
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/Materials_Stylized/4k JPEG/Stylized_02_Stone_Ground/Stylized_02_Stone_Ground_basecolor.jpg',
+        size:new Vector2(7,7)
+    })
 ));
 
 terrainTheme.rules.push(TerrainLayerRule.from(
@@ -158,7 +168,10 @@ terrainTheme.rules.push(TerrainLayerRule.from(
         ROAD_FILTER,
         CellFilterLerp.from(CellFilterLiteralFloat.from(1), CellFilterLiteralFloat.from(0.3), NOISE_10_a)
     ),
-    TERRAIN_LAYER_GRASS,
+    TerrainLayerDescription.from({
+        diffuse:'data/textures/materials/Sci-Fi Planet/Grass_02.png',
+        size:new Vector2(7,7)
+    }),
 ));
 
 SampleTheme0.terrain = terrainTheme;

package/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -1,9 +1,23 @@
 import { CellFilter } from "../../CellFilter.js";
 import { gaussian } from "../../../../core/math/gaussian.js";
-
+import { max2 } from "../../../../core/math/max2.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} samplesX
+ * @param {number} samplesY
+ * @param {number} sigma_x
+ * @param {number} sigma_y
+ * @return {number}
+ */
 function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
-    const half_samples_x = (samplesX / 2);
-    const half_samples_y = (samplesY / 2);
+    assert.isNonNegativeInteger(samplesX, 'samplesX');
+    assert.isNonNegativeInteger(samplesY, 'samplesY');
+
+    const half_samples_x = samplesX * 0.5;
+    const half_samples_y = samplesY * 0.5;
 
     let powerTotal = 0;
     let ix, iy;
@@ -70,6 +84,8 @@ export class CellFilterGaussianBlur extends CellFilter {
         if (!this.source.initialized) {
             this.source.initialize(grid, seed);
 
+            this.__kernel = new Float32Array(this.samples_x * this.samples_y);
+
             // initialize kernel
             this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
         }
@@ -84,13 +100,13 @@ export class CellFilterGaussianBlur extends CellFilter {
      * @param {number} quality
      * @returns {CellFilterGaussianBlur}
      */
-    static from(source, x, y, quality = 5) {
+    static from(source, x, y, quality = 3) {
         const r = new CellFilterGaussianBlur();
 
         r.source = source;
 
-        r.samples_x = quality * x;
-        r.samples_y = quality * y;
+        r.samples_x = max2(2, Math.round(quality * x));
+        r.samples_y = max2(2, Math.round(quality * y));
 
         r.size_x = x;
         r.size_y = y;
@@ -102,24 +118,24 @@ export class CellFilterGaussianBlur extends CellFilter {
         const samplesX = this.samples_x;
         const samplesY = this.samples_y;
 
-        const half_samples_x = (samplesX / 2);
-        const half_samples_y = (samplesY / 2);
+        const half_samples_x = (samplesX - 1) * 0.5;
+        const half_samples_y = (samplesY - 1) * 0.5;
 
         const sizeX = this.size_x;
         const sizeY = this.size_y;
 
-        const local_u_scale = 1 / samplesX;
-        const local_v_scale = 1 / samplesY;
+        const local_u_scale = 1 / (samplesX - 1);
+        const local_v_scale = 1 / (samplesY - 1);
 
         let sum = 0;
-        let ix, iy;
+        let ix, iy = 0;
 
         const source = this.source;
         const kernel = this.__kernel;
 
-        const i_samples_x = samplesX|0;
+        const i_samples_x = samplesX | 0;
 
-        for (iy = 0; iy < samplesY; iy++) {
+        for (; iy < samplesY; iy++) {
             const local_y = iy - half_samples_y;
 
             const ny = local_y * local_v_scale;

package/generation/grid/GridData.js

@@ -2,6 +2,7 @@ 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";
+import { max2 } from "../../core/math/max2.js";
 
 const scratch_match_counter = new MarkerMatchCounter();
 
@@ -167,8 +168,14 @@ export class GridData {
      * @param {number} height
      */
     resize(width, height) {
-        assert.typeOf(width, 'number', 'width');
-        assert.typeOf(height, 'number', 'height');
+        assert.isNumber(width, 'width');
+        assert.isNumber(height, 'height');
+
+        assert.isNonNegativeInteger(width,'width');
+        assert.isNonNegativeInteger(height,'height');
+
+        assert.isFiniteNumber(width, 'width');
+        assert.isFiniteNumber(height, 'width');
 
         if (width === this.width && height === this.height) {
             //no need, already the right size
@@ -187,6 +194,14 @@ export class GridData {
 
             layer.resize(width, height);
         }
+
+        // resize the quad tree pre-emptively, to avoid expensive re-balancing operations later on
+        this.markers.resize(
+            -max2(1, width * 0.5),
+            -max2(1, height * 0.5),
+            max2(width + 1, width * 1.5),
+            max2(height + 1, height * 1.5)
+        );
     }
 
     /**

package/generation/placement/GridCellPlacementRule.js

@@ -44,7 +44,7 @@ export class GridCellPlacementRule {
      * @param {Vector2} [offset]
      * @returns {GridCellPlacementRule}
      */
-    static from({ matcher, actions, probability, offset = Vector2.zero }) {
+    static from({ matcher, actions, probability = CellFilterLiteralFloat.from(1), offset = Vector2.zero }) {
 
         assert.defined(matcher);
         assert.defined(actions);
@@ -56,10 +56,8 @@ export class GridCellPlacementRule {
         r.pattern = matcher;
         r.actions = actions;
 
-        if (probability !== undefined) {
-            assert.equal(probability.isCellFilter, true, 'probability.isCellFilter !== true');
-            r.probability = probability;
-        }
+        assert.equal(probability.isCellFilter, true, 'probability.isCellFilter !== true');
+        r.probability = probability;
 
         r.positionOffset.copy(offset);
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.65",
+  "version": "2.33.70",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",