@woosh/meep-engine 2.33.69 → 2.33.70

package/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -10,6 +10,10 @@ import { obtainTerrain } from "../terrain/util/obtainTerrain.js";
 const v2 = new Vector2();
 
 export class FogOfWarRevealerSystem extends System {
+    /**
+     *
+     * @param {number} team
+     */
     constructor(team) {
         super();
 
@@ -19,6 +23,10 @@ export class FogOfWarRevealerSystem extends System {
 
         this.data = [];
 
+        /**
+         *
+         * @type {number}
+         */
         this.team = team;
     }
 

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -28,9 +28,10 @@ export function deinterleaveBufferAttribute(source_attribute) {
     attribute.normalized = source_attribute.normalized;
     attribute.name = source_attribute.name;
 
+    let i = 0, j = 0;
     // copy data
-    for (let i = 0; i < item_count; i++) {
-        for (let j = 0; j < itemSize; j++) {
+    for (; i < item_count; i++) {
+        for (j = 0; j < itemSize; j++) {
             destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
         }
     }

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/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/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.69",
+  "version": "2.33.70",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",