@woosh/meep-engine 3.56.0 → 3.58.0

package/src/generation/foliage/skeleton/tree_skeleton_grow_shoots.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Grows the peripheral twig system of every carrier named by `species.shoot_rules`, all together in the light they make
+ * for each other (`shoot_systems_simulate`), and writes the living axes into `skeleton`: each is a branch of its rule's
+ * `target` (or `short_target`) generator, one segment per annual unit, at its carrier's level + 1, so the LOD chain and
+ * the wind rig treat the system as one twig layer. Every carrier and axis records where each of its annual units starts
+ * (`TreeSkeleton.set_branch_units`), which is where its leaves are.
+ *
+ * The simulation runs for the tree's age: `ShootGrowthConfig.age`, or as long as the framework took to grow if that is
+ * longer. A carrier that stops growing before then grows on from its tip, and its extension is written onto it, so a
+ * tree grown from a seed leader is one stem from the ground up.
+ *
+ * The wood thickens with what it carries season by season during the simulation (`ShootGirth`): the twigs keep the
+ * radii it gave them, and the carriers and the framework above them are thickened in `skeleton`.
+ *
+ * Runs on its own seeded stream, so adding shoot rules leaves the framework where it grew.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ */
+export function tree_skeleton_grow_shoots(skeleton: import("./TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig): void;
+//# sourceMappingURL=tree_skeleton_grow_shoots.d.ts.map

package/src/generation/foliage/skeleton/tree_skeleton_grow_shoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_grow_shoots.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_grow_shoots.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AACH,oDAHW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,QAoGpE"}

package/src/generation/foliage/skeleton/tree_skeleton_grow_shoots.js

@@ -0,0 +1,327 @@
+import { assert } from "../../../core/assert.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { shoot_sample_unit_length } from "./shoot_demography.js";
+import { shoot_framework_buried, shoot_locate_on_chain, shoot_perpendicular3 } from "./shoot_geometry.js";
+import { shoot_systems_simulate } from "./shoot_systems_simulate.js";
+import { spine_frame_double_reflection } from "./spine_frame_double_reflection.js";
+
+const SCRATCH_P = new Float32Array(3);
+const SCRATCH_R = new Float32Array(3);
+const SCRATCH_RMF = new Float64Array(6);
+
+/**
+ * Grows the peripheral twig system of every carrier named by `species.shoot_rules`, all together in the light they make
+ * for each other (`shoot_systems_simulate`), and writes the living axes into `skeleton`: each is a branch of its rule's
+ * `target` (or `short_target`) generator, one segment per annual unit, at its carrier's level + 1, so the LOD chain and
+ * the wind rig treat the system as one twig layer. Every carrier and axis records where each of its annual units starts
+ * (`TreeSkeleton.set_branch_units`), which is where its leaves are.
+ *
+ * The simulation runs for the tree's age: `ShootGrowthConfig.age`, or as long as the framework took to grow if that is
+ * longer. A carrier that stops growing before then grows on from its tip, and its extension is written onto it, so a
+ * tree grown from a seed leader is one stem from the ground up.
+ *
+ * The wood thickens with what it carries season by season during the simulation (`ShootGirth`): the twigs keep the
+ * radii it gave them, and the carriers and the framework above them are thickened in `skeleton`.
+ *
+ * Runs on its own seeded stream, so adding shoot rules leaves the framework where it grew.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ */
+export function tree_skeleton_grow_shoots(skeleton, species) {
+    const rules = species.shoot_rules;
+    if (rules.length === 0) {
+        return;
+    }
+    const rng = seededRandom(((species.seed | 0) ^ 0x2F6B1C35) | 0);
+    const framework_count = skeleton.branch_count;
+    const nodes = [];
+    const edges = [];
+    const ages = framework_ages(skeleton, species.shoot_growth.leader_growth);
+    let years = 1;
+    for (let b = 0; b < framework_count; b++) years = Math.max(years, Math.round(ages[b]));
+    const seasons = Math.max(years, species.shoot_growth.age);
+
+    // The carriers, laid out in as many annual units as they are years old, each about its share of their length
+    /** @type {import("./shoot_systems_simulate.js").ShootCarrier[]} */
+    const carriers = [];
+    for (let r = 0; r < rules.length; r++) {
+        const rule = rules[r];
+        assert.ok(rule.source >= 0 && rule.target.every(t => rule.source < t && t < species.branches.length),
+            'shoot rule must satisfy 0 <= source < target < branches.length for every target');
+        if (rule.zones.some(z => z.short.some(p => p > 0))) {
+            assert.ok(rule.source < rule.short_target && rule.short_target < species.branches.length,
+                'a shoot rule that grows short shoots must satisfy source < short_target < branches.length');
+        }
+        for (let carrier = 0; carrier < framework_count; carrier++) {
+            if (skeleton.branch_generator[carrier] !== rule.source || skeleton.branch_dead[carrier]) continue;
+            const length = skeleton.branch_length[carrier];
+            if (!(length > 0)) continue;
+            skeleton.collect_branch_chain(carrier, nodes, edges);
+            if (edges.length === 0) continue;
+
+            const count = Math.max(1, Math.round(ages[carrier]));
+            const units = [];
+            let laid = 0;
+            for (let k = 0; k < count; k++) {
+                const len = shoot_sample_unit_length(rng, length / count, rule.carrier_order, rule);
+                units.push(len);
+                laid += len;
+            }
+            for (let k = 0; k < count; k++) units[k] *= length / laid;
+            units.reverse();
+            const starts = new Float64Array(units.length);
+            let arc = length;
+            for (let k = units.length - 1; k >= 0; k--) {
+                arc -= units[k];
+                starts[k] = arc;
+            }
+            const carrier_nodes = nodes.slice();
+            const carrier_edges = edges.slice();
+            const points = new Float64Array((units.length + 1) * 3);
+            for (let k = 0; k <= units.length; k++) {
+                const t = k < units.length ? starts[k] / length : 1;
+                const located = shoot_locate_on_chain(skeleton, carrier_nodes, carrier_edges, t);
+                skeleton.evaluate_segment_position(SCRATCH_P, 0, located.edge, located.u);
+                points[k * 3] = SCRATCH_P[0];
+                points[k * 3 + 1] = SCRATCH_P[1];
+                points[k * 3 + 2] = SCRATCH_P[2];
+            }
+            // every carrier's tip grew in the last season
+            carriers.push({
+                rule, carrier, length, nodes: carrier_nodes, edges: carrier_edges, units, starts, points,
+                first_season: Math.max(0, years - units.length)
+            });
+        }
+    }
+    if (carriers.length === 0) {
+        return;
+    }
+
+    const axes = shoot_systems_simulate(skeleton, species, carriers, seasons, rng);
+
+    // a carrier's extension becomes the rest of the carrier, before anything is located along it
+    for (const axis of axes) {
+        if (axis.extends) extend_carrier(skeleton, carriers[axis.system], axis);
+    }
+    for (const c of carriers) {
+        skeleton.set_branch_units(c.carrier, Array.from(c.starts, (a) => a / c.length));
+    }
+
+    // a short shoot grows millimetres a year and bears no laterals: one segment for all its years
+    for (const axis of axes) {
+        if (!axis.short || axis.units.length < 2) continue;
+        let total = 0;
+        for (let k = 0; k < axis.units.length; k++) total += axis.units[k];
+        const n = axis.units.length * 3;
+        axis.points = [axis.points[0], axis.points[1], axis.points[2], axis.points[n], axis.points[n + 1], axis.points[n + 2]];
+        axis.radii = [axis.radii[0], axis.radii[axis.radii.length - 1]];
+        axis.units = [total];
+        axis.unit_seasons = [axis.unit_seasons[axis.unit_seasons.length - 1]];
+    }
+
+    write_axes(skeleton, carriers, axes);
+
+    // framework wood its parent's thickening has grown over is dead
+    for (let b = 0; b < framework_count; b++) {
+        if (!skeleton.branch_dead[b] && shoot_framework_buried(skeleton, b)) skeleton.branch_dead[b] = 1;
+    }
+}
+
+/**
+ * Age (years) of every framework branch. Every branch elongates at `leader_growth`, from when its parent's growth
+ * reached where it joins: it was born that many years after its parent, and grew its length after that. The tree is as
+ * old as the last tip took to grow, and a branch is as old as the time since its birth: a branch that finished its
+ * length early grew slowly since, as an excurrent trunk's lower boughs and a decurrent crown's boughs do. A branch
+ * comes after its parent.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} leader_growth metres a year
+ * @returns {Float64Array}
+ */
+function framework_ages(skeleton, leader_growth) {
+    const birth = new Float64Array(skeleton.branch_count);
+    let age = 0;
+    for (let b = 0; b < skeleton.branch_count; b++) {
+        const p = skeleton.branch_parent[b];
+        birth[b] = p < 0 ? 0 : birth[p] + skeleton.branch_parent_attach_t[b] * skeleton.branch_length[p] / leader_growth;
+        age = Math.max(age, birth[b] + skeleton.branch_length[b] / leader_growth);
+    }
+    const ages = new Float64Array(skeleton.branch_count);
+    for (let b = 0; b < skeleton.branch_count; b++) {
+        ages[b] = Math.max(1, age - birth[b]);
+    }
+    return ages;
+}
+
+
+
+/**
+ * Writes carrier `c`'s extension onto the end of it: a node at each of its unit boundaries with its radii, a segment a
+ * unit. The carrier's nodes, the framework branches it carries and its scars keep their place along it as it grows
+ * longer; its record of units gains the extension's. The extension's segments are left in `axis.edges`.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("./shoot_systems_simulate.js").ShootCarrier} c
+ * @param {import("./shoot_systems_simulate.js").ShootAxis & {edges?: number[]}} axis
+ */
+function extend_carrier(skeleton, c, axis) {
+    const b = c.carrier;
+    const old_length = c.length;
+    let added = 0;
+    for (let k = 0; k < axis.units.length; k++) added += axis.units[k];
+    const length = old_length + added;
+    const scale = old_length / length;
+
+    for (let i = 0; i < c.nodes.length; i++) {
+        skeleton.node_write_t_norm(c.nodes[i], skeleton.node_t_norm(c.nodes[i]) * scale);
+    }
+    for (let child = 0; child < skeleton.branch_count; child++) {
+        if (skeleton.branch_parent[child] === b) skeleton.branch_parent_attach_t[child] *= scale;
+    }
+    for (let i = 0; i < skeleton.scar_count; i++) {
+        if (skeleton.scar_branch[i] === b) skeleton.scar_data[i * 5] *= scale;
+    }
+
+    const level = skeleton.branch_level[b];
+    const parent_branch = skeleton.branch_parent[b];
+    const phase = skeleton.branch_phase_hash[b];
+    let prev_v = skeleton.branch_tip_vertex[b];
+    const arc_base = skeleton.node_arc_s(prev_v);
+    skeleton.node_read_frame_r(SCRATCH_R, 0, prev_v);
+    let rx = SCRATCH_R[0], ry = SCRATCH_R[1], rz = SCRATCH_R[2];
+    skeleton.node_read_tangent(SCRATCH_P, 0, prev_v);
+    let tx = SCRATCH_P[0], ty = SCRATCH_P[1], tz = SCRATCH_P[2];
+    const pts = axis.points;
+    let px = pts[0], py = pts[1], pz = pts[2];
+    const starts = Array.from(c.starts);
+    const units = c.units.slice();
+    const edges = [];
+    let arc = old_length;
+    for (let k = 0; k < axis.units.length; k++) {
+        const len = axis.units[k];
+        const nx = pts[(k + 1) * 3], ny = pts[(k + 1) * 3 + 1], nz = pts[(k + 1) * 3 + 2];
+        const d = Math.max(1e-9, Math.hypot(nx - px, ny - py, nz - pz));
+        const ntx = (nx - px) / d, nty = (ny - py) / d, ntz = (nz - pz) / d;
+        spine_frame_double_reflection(SCRATCH_RMF, 0, px, py, pz, tx, ty, tz, rx, ry, rz, nx, ny, nz, ntx, nty, ntz);
+        rx = SCRATCH_RMF[0];
+        ry = SCRATCH_RMF[1];
+        rz = SCRATCH_RMF[2];
+        tx = ntx;
+        ty = nty;
+        tz = ntz;
+        starts.push(arc);
+        units.push(len);
+        const t_prev = arc / length;
+        arc += len;
+        const curr_v = skeleton.add_node(nx, ny, nz, tx, ty, tz, rx, ry, rz, axis.radii[k + 1], b, level, parent_branch, arc / length, arc_base + arc - old_length, phase);
+        edges.push(skeleton.add_segment(prev_v, curr_v, tx * len, ty * len, tz * len, tx * len, ty * len, tz * len, len, t_prev));
+        c.nodes.push(curr_v);
+        c.edges.push(edges[k]);
+        prev_v = curr_v;
+        px = nx;
+        py = ny;
+        pz = nz;
+    }
+    skeleton.branch_tip_vertex[b] = prev_v;
+    skeleton.branch_length[b] = length;
+    c.length = length;
+    c.units = units;
+    c.starts = Float64Array.from(starts);
+    axis.edges = edges;
+}
+
+/**
+ * Writes every axis as a branch: nodes at its unit boundaries with its radii, a segment a unit,
+ * hanging from its mother's unit (or its carrier) where it grew, and its unit record.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("./shoot_systems_simulate.js").ShootCarrier[]} carriers
+ * @param {import("./shoot_systems_simulate.js").ShootAxis[]} axes
+ */
+function write_axes(skeleton, carriers, axes) {
+    const written_branch = new Int32Array(axes.length).fill(-1);
+    const written_edges = new Array(axes.length);
+    for (let m = 0; m < axes.length; m++) {
+        const axis = axes[m];
+        const c = carriers[axis.system];
+        if (axis.extends) {
+            written_branch[m] = c.carrier;
+            written_edges[m] = axis.edges;
+            continue;
+        }
+
+        let parent_branch;
+        let anchor_edge;
+        let anchor_u;
+        if (axis.parent < 0) {
+            parent_branch = c.carrier;
+            const located = shoot_locate_on_chain(skeleton, c.nodes, c.edges, (c.starts[axis.parent_unit] + axis.u * c.units[axis.parent_unit]) / c.length);
+            anchor_edge = located.edge;
+            anchor_u = located.u;
+        } else {
+            parent_branch = written_branch[axis.parent];
+            anchor_edge = written_edges[axis.parent][axis.parent_unit];
+            anchor_u = axis.u;
+        }
+        const attach_vertex = skeleton.segment_v0(anchor_edge);
+        const v_end = skeleton.segment_v1(anchor_edge);
+        const parent_t = skeleton.node_t_norm(attach_vertex) + (skeleton.node_t_norm(v_end) - skeleton.node_t_norm(attach_vertex)) * anchor_u;
+        const level = skeleton.branch_level[c.carrier] + 1;
+
+        const units = axis.units;
+        const n = units.length;
+        let total = 0;
+        for (let k = 0; k < n; k++) total += units[k];
+        const pts = axis.points;
+        const r = axis.radii;
+
+        let tx = pts[3] - pts[0], ty = pts[4] - pts[1], tz = pts[5] - pts[2];
+        const t_len = Math.max(1e-9, Math.hypot(tx, ty, tz));
+        tx /= t_len;
+        ty /= t_len;
+        tz /= t_len;
+        shoot_perpendicular3(SCRATCH_R, tx, ty, tz);
+        let rx = SCRATCH_R[0], ry = SCRATCH_R[1], rz = SCRATCH_R[2];
+
+        const branch_id = skeleton.add_branch(0, level, axis.generator, parent_branch, anchor_edge, parent_t, total, r[0], axis.phase);
+        let prev_v = skeleton.add_node(pts[0], pts[1], pts[2], tx, ty, tz, rx, ry, rz, r[0], branch_id, level, parent_branch, 0.0, 0.0, axis.phase);
+        skeleton.connect_nodes(attach_vertex, prev_v);
+        skeleton.branch_root_vertex[branch_id] = prev_v;
+
+        const unit_edges = new Array(n);
+        const unit_starts = new Array(n);
+        let arc = 0;
+        let px = pts[0], py = pts[1], pz = pts[2];
+        for (let k = 0; k < n; k++) {
+            const len = units[k];
+            const nx = pts[(k + 1) * 3], ny = pts[(k + 1) * 3 + 1], nz = pts[(k + 1) * 3 + 2];
+            const d = Math.max(1e-9, Math.hypot(nx - px, ny - py, nz - pz));
+            tx = (nx - px) / d;
+            ty = (ny - py) / d;
+            tz = (nz - pz) / d;
+            spine_frame_double_reflection(SCRATCH_RMF, 0, px, py, pz, tx, ty, tz, rx, ry, rz, nx, ny, nz, tx, ty, tz);
+            rx = SCRATCH_RMF[0];
+            ry = SCRATCH_RMF[1];
+            rz = SCRATCH_RMF[2];
+            unit_starts[k] = arc / total;
+            arc += len;
+            const curr_v = skeleton.add_node(nx, ny, nz, tx, ty, tz, rx, ry, rz, r[k + 1], branch_id, level, parent_branch, arc / total, arc, axis.phase);
+            const t_prev = unit_starts[k];
+            unit_edges[k] = skeleton.add_segment(prev_v, curr_v, tx * len, ty * len, tz * len, tx * len, ty * len, tz * len, len, t_prev === 0 ? parent_t : t_prev);
+            prev_v = curr_v;
+            px = nx;
+            py = ny;
+            pz = nz;
+        }
+        skeleton.branch_tip_vertex[branch_id] = prev_v;
+        skeleton.branch_length[branch_id] = total;
+        skeleton.set_branch_units(branch_id, unit_starts);
+
+        written_branch[m] = branch_id;
+        written_edges[m] = unit_edges;
+    }
+}
+
+
+

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_motion.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How the wind joints bound to a skeleton's nodes move: each joint's parent, where it pivots, and how far it turns
+ * the wood it carries in the reference wind (`tree_skeleton_assign_skin_joints`). A skeleton never skinned has one
+ * joint, which does not turn.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @returns {{parents: Int32Array, pivots: Float32Array, rotation: Float32Array}} `pivots` 3 per joint
+ */
+export function tree_skeleton_read_joint_motion(skeleton: import("./TreeSkeleton.js").TreeSkeleton): {
+    parents: Int32Array;
+    pivots: Float32Array;
+    rotation: Float32Array;
+};
+//# sourceMappingURL=tree_skeleton_read_joint_motion.d.ts.map

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_read_joint_motion.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_read_joint_motion.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,0DAHW,OAAO,mBAAmB,EAAE,YAAY,GACtC;IAAC,OAAO,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAC,CAe/E"}

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_motion.js

@@ -0,0 +1,26 @@
+import { tree_skeleton_read_joint_parents } from "./tree_skeleton_read_joint_parents.js";
+
+const SCRATCH_P = new Float32Array(3);
+
+/**
+ * How the wind joints bound to a skeleton's nodes move: each joint's parent, where it pivots, and how far it turns
+ * the wood it carries in the reference wind (`tree_skeleton_assign_skin_joints`). A skeleton never skinned has one
+ * joint, which does not turn.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @returns {{parents: Int32Array, pivots: Float32Array, rotation: Float32Array}} `pivots` 3 per joint
+ */
+export function tree_skeleton_read_joint_motion(skeleton) {
+    const parents = tree_skeleton_read_joint_parents(skeleton);
+    const n = parents.length;
+    const pivots = new Float32Array(n * 3);
+    const rotation = new Float32Array(n);
+    for (let j = 0; j < Math.min(n, skeleton.joint_count); j++) {
+        skeleton.node_read_position(SCRATCH_P, 0, skeleton.joint_vertex[j]);
+        pivots[j * 3] = SCRATCH_P[0];
+        pivots[j * 3 + 1] = SCRATCH_P[1];
+        pivots[j * 3 + 2] = SCRATCH_P[2];
+        rotation[j] = skeleton.joint_rotation[j];
+    }
+    return { parents, pivots, rotation };
+}

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_parents.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parent of every wind joint, read back from the `[primary_joint, parent_joint]` pair that
+ * `tree_skeleton_assign_skin_joints` writes on every node: every node bound to joint `j` carries `j`'s parent.
+ * Joint 0, the trunk base, gets `-1`.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @returns {Int32Array}
+ */
+export function tree_skeleton_read_joint_parents(skeleton: import("./TreeSkeleton.js").TreeSkeleton): Int32Array;
+//# sourceMappingURL=tree_skeleton_read_joint_parents.d.ts.map

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_parents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_read_joint_parents.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_read_joint_parents.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,2DAHW,OAAO,mBAAmB,EAAE,YAAY,GACtC,UAAU,CAatB"}

package/src/generation/foliage/skeleton/tree_skeleton_read_joint_parents.js

@@ -0,0 +1,20 @@
+/**
+ * Parent of every wind joint, read back from the `[primary_joint, parent_joint]` pair that
+ * `tree_skeleton_assign_skin_joints` writes on every node: every node bound to joint `j` carries `j`'s parent.
+ * Joint 0, the trunk base, gets `-1`.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @returns {Int32Array}
+ */
+export function tree_skeleton_read_joint_parents(skeleton) {
+    let joint_count = 1;
+    for (let v = 0; v < skeleton.node_count; v++) {
+        joint_count = Math.max(joint_count, skeleton.node_read_joint(v, 0) + 1);
+    }
+    const parents = new Int32Array(joint_count);
+    for (let v = 0; v < skeleton.node_count; v++) {
+        parents[skeleton.node_read_joint(v, 0)] = skeleton.node_read_joint(v, 1);
+    }
+    parents[0] = -1;
+    return parents;
+}

package/src/generation/grid/generation/road/GridTaskGenerateRoads.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridTaskGenerateRoads.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/grid/generation/road/GridTaskGenerateRoads.js"],"names":[],"mappings":"AAubA;IA4CI;;;;;;;OAOG;IACH;QAL4B,IAAI,GAArB,MAAM;QACe,WAAW;QACN,OAAO,EAAjC,gBAAgB;QACd,qBAAqB,CAqBjC;IArED;;;OAGG;IACH,yBAAmB;IAEnB;;;OAGG;IACH,SAFU,gBAAgB,CAEb;IAEb;;;OAGG;IACH,yBAFU,MAAM,EAAE,CAShB;IAEF;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAahB;IAsCF,iDA+FC;CACJ;kCA5lBiC,4BAA4B;sBAJxC,4CAA4C"}
+{"version":3,"file":"GridTaskGenerateRoads.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/grid/generation/road/GridTaskGenerateRoads.js"],"names":[],"mappings":"AAubA;IA4CI;;;;;;;OAOG;IACH;QAL4B,IAAI,GAArB,MAAM;QACe,WAAW;QACN,OAAO,EAAjC,gBAAgB;QACd,qBAAqB,CAqBjC;IArED;;;OAGG;IACH,yBAAmB;IAEnB;;;OAGG;IACH,SAFU,gBAAgB,CAEb;IAEb;;;OAGG;IACH,yBAFU,MAAM,EAAE,CAShB;IAEF;;;OAGG;IACH,uBAFU,MAAM,EAAE,CAahB;IAsCF,iDAkGC;CACJ;kCA/lBiC,4BAA4B;sBAJxC,4CAA4C"}

package/src/generation/grid/generation/road/GridTaskGenerateRoads.js

@@ -536,7 +536,8 @@ export class GridTaskGenerateRoads extends GridTaskGenerator {
 
         const random = seededRandom(seed);
 
-        const tInitializeActions = actionTask(() => {
+        const tInitializeActions = actionTask(() => {
+            traversable.initialize(grid, seed);
             this.actions.forEach(a => {
                 a.initialize(grid, seed);
             });
@@ -591,6 +592,8 @@ export class GridTaskGenerateRoads extends GridTaskGenerator {
             traversable
         });
 
+        tBuildDistanceField.addDependency(tInitializeActions);
+        tBuildPaths.addDependency(tInitializeActions);
         tBuildPaths.addDependency(tCollectConnectors);
         tBuildPaths.addDependency(tBuildDistanceField);
 

package/src/generation/markers/GridCellActionPlaceMarkerGroup.d.ts

@@ -10,6 +10,7 @@ export class GridCellActionPlaceMarkerGroup extends GridCellAction {
      * @type {GridCellActionPlaceMarker[]}
      */
     children: GridCellActionPlaceMarker[];
+    initialize(data: any, seed: any): void;
     /**
      * Tests the children's geometric footprints against existing markers. Transformers are NOT
      * applied (they may be stateful, and a test must not have side effects), so position changes

package/src/generation/markers/GridCellActionPlaceMarkerGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridCellActionPlaceMarkerGroup.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridCellActionPlaceMarkerGroup.js"],"names":[],"mappings":"AAWA;IASI;;;;OAIG;IACH,sBAHW,8BAA8B,GAC5B,8BAA8B,CAU1C;IApBD;;;OAGG;IACH,UAFU,2BAA2B,CAEvB;IAkBd;;;;;;;;;;OAUG;IACH,sCANW,MAAM,KACN,MAAM,YACN,MAAM,+BAEJ,OAAO,CAoBnB;IAMD,wDAcC;CACJ;+BArF8B,uCAAuC"}
+{"version":3,"file":"GridCellActionPlaceMarkerGroup.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridCellActionPlaceMarkerGroup.js"],"names":[],"mappings":"AAWA;IASI;;;;OAIG;IACH,sBAHW,8BAA8B,GAC5B,8BAA8B,CAU1C;IApBD;;;OAGG;IACH,UAFU,2BAA2B,CAEvB;IAkBd,uCAUC;IAED;;;;;;;;;;OAUG;IACH,sCANW,MAAM,KACN,MAAM,YACN,MAAM,+BAEJ,OAAO,CAoBnB;IAMD,wDAcC;CACJ;+BAjG8B,uCAAuC"}

package/src/generation/markers/GridCellActionPlaceMarkerGroup.js

@@ -1,86 +1,98 @@
-import { GridCellAction } from "../placement/action/GridCellAction.js";
-import { assert } from "../../core/assert.js";
-import { compute_writes_union } from "../compute_writes_union.js";
-
-/**
- * Group IDs are opaque: unique within a session and only meaningful for equality
- * comparison. Their absolute values are NOT reproducible across runs.
- * @type {number}
- */
-let idCounter = 0;
-
-export class GridCellActionPlaceMarkerGroup extends GridCellAction {
-
-    /**
-     *
-     * @type {GridCellActionPlaceMarker[]}
-     */
-    children = [];
-
-
-    /**
-     *
-     * @param {GridCellActionPlaceMarkerGroup} children
-     * @returns {GridCellActionPlaceMarkerGroup}
-     */
-    static from(children) {
-        assert.isArray(children, 'children');
-
-        const r = new GridCellActionPlaceMarkerGroup();
-
-        r.children = children;
-
-        return r;
-    }
-
-    /**
-     * Tests the children's geometric footprints against existing markers. Transformers are NOT
-     * applied (they may be stateful, and a test must not have side effects), so position changes
-     * made by transformers are not reflected in this check.
-     * @param {GridData} data
-     * @param {number} x
-     * @param {number} y
-     * @param {number} rotation
-     * @param {MarkerNodeMatcher} matcher
-     * @returns {boolean} True if a collision exists
-     */
-    testNodeCollisions(data, x, y, rotation, matcher) {
-
-        const children = this.children;
-        const n = children.length;
-
-        for (let i = 0; i < n; i++) {
-            const child = children[i];
-
-            const node = child.buildBaseNode(data, x, y, rotation);
-
-            const collision = data.containsMarkerInCircle(node.position.x, node.position.y, node.size, matcher);
-
-            if (collision) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    computeWrites() {
-        return compute_writes_union(this.children);
-    }
-
-    execute(data, x, y, rotation) {
-        const id = idCounter++;
-
-        const children = this.children;
-        const n = children.length;
-        for (let i = 0; i < n; i++) {
-            const child = children[i];
-
-            const node = child.buildNode(data, x, y, rotation);
-
-            node.properties.groupId = id;
-
-            data.addMarker(node);
-        }
-    }
-}
+import { GridCellAction } from "../placement/action/GridCellAction.js";
+import { assert } from "../../core/assert.js";
+import { compute_writes_union } from "../compute_writes_union.js";
+
+/**
+ * Group IDs are opaque: unique within a session and only meaningful for equality
+ * comparison. Their absolute values are NOT reproducible across runs.
+ * @type {number}
+ */
+let idCounter = 0;
+
+export class GridCellActionPlaceMarkerGroup extends GridCellAction {
+
+    /**
+     *
+     * @type {GridCellActionPlaceMarker[]}
+     */
+    children = [];
+
+
+    /**
+     *
+     * @param {GridCellActionPlaceMarkerGroup} children
+     * @returns {GridCellActionPlaceMarkerGroup}
+     */
+    static from(children) {
+        assert.isArray(children, 'children');
+
+        const r = new GridCellActionPlaceMarkerGroup();
+
+        r.children = children;
+
+        return r;
+    }
+
+    initialize(data, seed) {
+        super.initialize(data, seed);
+
+        const children = this.children;
+        const n = children.length;
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            child.initialize(data, seed);
+        }
+    }
+
+    /**
+     * Tests the children's geometric footprints against existing markers. Transformers are NOT
+     * applied (they may be stateful, and a test must not have side effects), so position changes
+     * made by transformers are not reflected in this check.
+     * @param {GridData} data
+     * @param {number} x
+     * @param {number} y
+     * @param {number} rotation
+     * @param {MarkerNodeMatcher} matcher
+     * @returns {boolean} True if a collision exists
+     */
+    testNodeCollisions(data, x, y, rotation, matcher) {
+
+        const children = this.children;
+        const n = children.length;
+
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            const node = child.buildBaseNode(data, x, y, rotation);
+
+            const collision = data.containsMarkerInCircle(node.position.x, node.position.y, node.size, matcher);
+
+            if (collision) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    computeWrites() {
+        return compute_writes_union(this.children);
+    }
+
+    execute(data, x, y, rotation) {
+        const id = idCounter++;
+
+        const children = this.children;
+        const n = children.length;
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            const node = child.buildNode(data, x, y, rotation);
+
+            node.properties.groupId = id;
+
+            data.addMarker(node);
+        }
+    }
+}