@pascal-app/core 0.8.0 → 0.9.1

package/dist/systems/elevator/elevator-opening-sync.js

@@ -0,0 +1,218 @@
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { resolveElevatorServiceLevels } from './elevator-service';
+const ELEVATOR_OPENING_PADDING = 0.08;
+const DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS = 0.09;
+function pointsEqual(a, b, tolerance = 1e-5) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function polygonsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((polygon, polygonIndex) => {
+        const other = right[polygonIndex];
+        if (!(other && polygon.length === other.length))
+            return false;
+        return polygon.every((point, pointIndex) => {
+            const otherPoint = other[pointIndex];
+            if (!otherPoint)
+                return false;
+            return pointsEqual(point, otherPoint);
+        });
+    });
+}
+function metadataEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((entry, index) => entry.source === right[index]?.source &&
+        (entry.elevatorId ?? null) === (right[index]?.elevatorId ?? null) &&
+        (entry.stairId ?? null) === (right[index]?.stairId ?? null));
+}
+function normalizeExistingMetadata(holes, metadata) {
+    return holes.map((_, index) => metadata?.[index] ?? { source: 'manual' });
+}
+function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+function pointOnSegment(point, a, b, tolerance = 1e-6) {
+    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
+    if (Math.abs(cross) > tolerance)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -tolerance)
+        return false;
+    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    return dot <= lenSq + tolerance;
+}
+function pointInPolygon(point, polygon) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    const [x, z] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[i];
+        const b = polygon[j];
+        if (pointOnSegment(point, a, b))
+            return true;
+        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function polygonContainsPolygon(outer, inner) {
+    return inner.every((point) => pointInPolygon(point, outer));
+}
+function isCoveredByExistingHole(existingHoles, autoHole) {
+    return existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole));
+}
+function getServedLevelRange(elevator, nodes) {
+    const servedLevels = resolveElevatorServiceLevels(elevator, nodes);
+    if (servedLevels.length < 2)
+        return null;
+    const levelNumbers = servedLevels.map((level) => level.level);
+    return {
+        max: Math.max(...levelNumbers),
+        min: Math.min(...levelNumbers),
+        sortedServedLevels: servedLevels,
+    };
+}
+function getLevelNumber(levelId, nodes) {
+    if (!levelId)
+        return undefined;
+    const node = nodes[levelId];
+    return node?.type === 'level' ? node.level : undefined;
+}
+function shouldApplyElevatorToSlab(elevator, slabLevelId, nodes) {
+    const range = getServedLevelRange(elevator, nodes);
+    if (!range)
+        return false;
+    const slabLevel = getLevelNumber(slabLevelId, nodes);
+    if (slabLevel !== undefined) {
+        return slabLevel > range.min && slabLevel <= range.max;
+    }
+    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === slabLevelId);
+    return servedIndex > 0;
+}
+function shouldApplyElevatorToCeiling(elevator, ceilingLevelId, nodes) {
+    const range = getServedLevelRange(elevator, nodes);
+    if (!range)
+        return false;
+    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
+    if (ceilingLevel !== undefined) {
+        return ceilingLevel >= range.min && ceilingLevel < range.max;
+    }
+    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === ceilingLevelId);
+    return servedIndex >= 0 && servedIndex < range.sortedServedLevels.length - 1;
+}
+function getElevatorOpeningPolygon(elevator) {
+    const wallThickness = Math.max(elevator.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, 0.04);
+    const shaftWidth = Math.max(elevator.shaftWidth ?? elevator.width, elevator.width, 0.8);
+    const shaftDepth = Math.max(elevator.shaftDepth ?? elevator.depth, elevator.depth, 0.8);
+    const halfWidth = shaftWidth / 2 + wallThickness + ELEVATOR_OPENING_PADDING;
+    const halfDepth = shaftDepth / 2 + wallThickness + ELEVATOR_OPENING_PADDING;
+    const corners = [
+        [-halfWidth, -halfDepth],
+        [halfWidth, -halfDepth],
+        [halfWidth, halfDepth],
+        [-halfWidth, halfDepth],
+    ];
+    return corners.map(([x, z]) => {
+        const [rotatedX, rotatedZ] = rotateXZ(x, z, elevator.rotation ?? 0);
+        return [elevator.position[0] + rotatedX, elevator.position[2] + rotatedZ];
+    });
+}
+export function syncAutoElevatorOpenings(nodes) {
+    const elevators = Object.values(nodes).filter((node) => node.type === 'elevator' && node.visible !== false);
+    const slabs = Object.values(nodes).filter((node) => node.type === 'slab');
+    const ceilings = Object.values(nodes).filter((node) => node.type === 'ceiling');
+    const updates = [];
+    for (const slab of slabs) {
+        const slabLevelId = resolveLevelId(slab, nodes);
+        const existingHoles = slab.holes ?? [];
+        const existingMetadata = normalizeExistingMetadata(existingHoles, slab.holeMetadata);
+        const preservedHoles = existingHoles
+            .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
+            .filter((entry) => entry.metadata.source !== 'elevator');
+        const manualHoles = preservedHoles.filter((entry) => entry.metadata.source !== 'stair');
+        const stairHoles = preservedHoles.filter((entry) => entry.metadata.source === 'stair');
+        const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
+        const elevatorHoles = elevators
+            .filter((elevator) => shouldApplyElevatorToSlab(elevator, slabLevelId, nodes))
+            .map((elevator) => ({
+            polygon: getElevatorOpeningPolygon(elevator),
+            metadata: {
+                elevatorId: elevator.id,
+                source: 'elevator',
+            },
+        }))
+            .filter((hole) => polygonContainsPolygon(slab.polygon, hole.polygon))
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...manualHoles.map((hole) => hole.polygon),
+            ...elevatorHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...manualHoles.map((hole) => ({ ...hole.metadata })),
+            ...elevatorHoles.map((hole) => hole.metadata),
+            ...stairHoles.map((hole) => ({ ...hole.metadata })),
+        ];
+        if (!polygonsEqual(existingHoles, nextHoles) ||
+            !metadataEqual(existingMetadata, nextMetadata)) {
+            updates.push({
+                id: slab.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    for (const ceiling of ceilings) {
+        const ceilingLevelId = resolveLevelId(ceiling, nodes);
+        const existingHoles = ceiling.holes ?? [];
+        const existingMetadata = normalizeExistingMetadata(existingHoles, ceiling.holeMetadata);
+        const preservedHoles = existingHoles
+            .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
+            .filter((entry) => entry.metadata.source !== 'elevator');
+        const manualHoles = preservedHoles.filter((entry) => entry.metadata.source !== 'stair');
+        const stairHoles = preservedHoles.filter((entry) => entry.metadata.source === 'stair');
+        const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
+        const elevatorHoles = elevators
+            .filter((elevator) => shouldApplyElevatorToCeiling(elevator, ceilingLevelId, nodes))
+            .map((elevator) => ({
+            polygon: getElevatorOpeningPolygon(elevator),
+            metadata: {
+                elevatorId: elevator.id,
+                source: 'elevator',
+            },
+        }))
+            .filter((hole) => polygonContainsPolygon(ceiling.polygon, hole.polygon))
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...manualHoles.map((hole) => hole.polygon),
+            ...elevatorHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...manualHoles.map((hole) => ({ ...hole.metadata })),
+            ...elevatorHoles.map((hole) => hole.metadata),
+            ...stairHoles.map((hole) => ({ ...hole.metadata })),
+        ];
+        if (!polygonsEqual(existingHoles, nextHoles) ||
+            !metadataEqual(existingMetadata, nextMetadata)) {
+            updates.push({
+                id: ceiling.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    return updates;
+}

package/dist/systems/elevator/elevator-opening-sync.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=elevator-opening-sync.test.d.ts.map

package/dist/systems/elevator/elevator-opening-sync.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-opening-sync.test.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.test.ts"],"names":[],"mappings":""}

package/dist/systems/elevator/elevator-opening-sync.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, test } from 'bun:test';
+import { BuildingNode, CeilingNode, ElevatorNode, LevelNode, SlabNode } from '../../schema';
+import { syncAutoElevatorOpenings } from './elevator-opening-sync';
+describe('syncAutoElevatorOpenings', () => {
+    test('does not add elevator holes when a manual surface hole already covers them', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const manualOpening = [
+            [1, 0.5],
+            [3, 0.5],
+            [3, 2.5],
+            [1, 2.5],
+        ];
+        const sourceCeiling = CeilingNode.parse({
+            name: 'Source Ceiling',
+            parentId: ground.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, sourceCeiling, upperSlab].map((node) => [
+            node.id,
+            node,
+        ]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        expect(updates.find((update) => update.id === upperSlab.id)).toBeUndefined();
+        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
+    });
+    test('adds elevator holes when an existing manual hole is too small', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const smallManualOpening = [
+            [1.7, 1.2],
+            [2.3, 1.2],
+            [2.3, 1.8],
+            [1.7, 1.8],
+        ];
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [smallManualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
+        expect(slabUpdate?.data.holes).toHaveLength(2);
+        expect(slabUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
+        expect(slabUpdate?.data.holeMetadata).toEqual([
+            { source: 'manual' },
+            { source: 'elevator', elevatorId: elevator.id },
+        ]);
+    });
+    test('removes stale auto elevator holes when a manual hole overlaps the elevator opening', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const manualOpening = [
+            [1, 0.5],
+            [3, 0.5],
+            [3, 2.5],
+            [1, 2.5],
+        ];
+        const staleAutoOpening = [
+            [1.12, 0.62],
+            [2.88, 0.62],
+            [2.88, 2.38],
+            [1.12, 2.38],
+        ];
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening, staleAutoOpening],
+            holeMetadata: [{ source: 'manual' }, { source: 'elevator', elevatorId: elevator.id }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
+        expect(slabUpdate?.data.holes).toEqual([manualOpening]);
+        expect(slabUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
+    });
+});

package/dist/systems/elevator/elevator-opening-system.d.ts

@@ -0,0 +1,2 @@
+export declare const ElevatorOpeningSystem: () => null;
+//# sourceMappingURL=elevator-opening-system.d.ts.map

package/dist/systems/elevator/elevator-opening-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,qBAAqB,YAuBjC,CAAA"}

package/dist/systems/elevator/elevator-opening-system.js

@@ -0,0 +1,48 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import useScene from '../../store/use-scene';
+import { syncAutoElevatorOpenings } from './elevator-opening-sync';
+function isOpeningRelevantNode(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'elevator' ||
+        node?.type === 'level' ||
+        node?.type === 'slab');
+}
+function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
+    if (nextNodes === prevNodes)
+        return false;
+    const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)]);
+    for (const id of ids) {
+        const nextNode = nextNodes[id];
+        const prevNode = prevNodes[id];
+        if (nextNode === prevNode)
+            continue;
+        if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode))
+            return true;
+    }
+    return false;
+}
+export const ElevatorOpeningSystem = () => {
+    const syncingAutoOpeningsRef = useRef(false);
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            useScene.getState().updateNodes(updates);
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
+        return useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+                return;
+            applyUpdates(syncAutoElevatorOpenings(state.nodes));
+        });
+    }, []);
+    return null;
+};

package/dist/systems/elevator/elevator-runtime-system.d.ts

@@ -0,0 +1,2 @@
+export declare function ElevatorRuntimeSystem(): null;
+//# sourceMappingURL=elevator-runtime-system.d.ts.map

package/dist/systems/elevator/elevator-runtime-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-runtime-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime-system.tsx"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,SAMpC"}

package/dist/systems/elevator/elevator-runtime-system.js

@@ -0,0 +1,8 @@
+import { useFrame } from '@react-three/fiber';
+import { stepElevatorRuntimes } from './elevator-runtime';
+export function ElevatorRuntimeSystem() {
+    useFrame(({ clock }, delta) => {
+        stepElevatorRuntimes(clock.getElapsedTime() * 1000, delta);
+    }, 2);
+    return null;
+}

package/dist/systems/elevator/elevator-runtime.d.ts

@@ -0,0 +1,18 @@
+import type { AnyNodeId, ElevatorNode } from '../../schema';
+import { type ElevatorInteractiveState } from '../../store/use-interactive';
+import { type ElevatorLevelEntry } from './elevator-service';
+export declare function createElevatorInteractiveState(levelId: AnyNodeId, carY: number): ElevatorInteractiveState;
+export declare function queueElevatorRequest(state: ElevatorInteractiveState, levelId: AnyNodeId): ElevatorInteractiveState;
+export declare function openElevatorDoorState(state: ElevatorInteractiveState): ElevatorInteractiveState;
+export declare function requestElevatorLevel(elevatorId: AnyNodeId, levelId: AnyNodeId): void;
+export declare function openElevatorDoor(elevatorId: AnyNodeId): void;
+export declare function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entries, now, state, }: {
+    defaultEntry: ElevatorLevelEntry;
+    delta: number;
+    elevator: ElevatorNode;
+    entries: ElevatorLevelEntry[];
+    now: number;
+    state: ElevatorInteractiveState;
+}): ElevatorInteractiveState;
+export declare function stepElevatorRuntimes(now: number, delta: number): void;
+//# sourceMappingURL=elevator-runtime.d.ts.map

package/dist/systems/elevator/elevator-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-runtime.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EAAE,KAAK,wBAAwB,EAAkB,MAAM,6BAA6B,CAAA;AAE3F,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,oBAAoB,CAAA;AAUnF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,SAAS,EAClB,IAAI,EAAE,MAAM,GACX,wBAAwB,CAW1B;AA8BD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,EAAE,SAAS,GACjB,wBAAwB,CAW1B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,GAAG,wBAAwB,CAQ/F;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,QAS7E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,QASrD;AAED,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,YAAY,EAAE,kBAAkB,CAAA;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,YAAY,CAAA;IACtB,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,wBAAwB,CAAA;CAChC,GAAG,wBAAwB,CAmH3B;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAsC9D"}