@lagless/2d-map-generator 0.0.48

package/LICENSE

@@ -0,0 +1,26 @@
+Creative Commons Attribution-NonCommercial 4.0 International
+
+Copyright (c) 2025 Lagless
+
+This work is licensed under the Creative Commons
+Attribution-NonCommercial 4.0 International License.
+
+You are free to:
+
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+
+  Attribution — You must give appropriate credit, provide a link to
+  the license, and indicate if changes were made. You may do so in
+  any reasonable manner, but not in any way that suggests the licensor
+  endorses you or your use.
+
+  NonCommercial — You may not use the material for commercial purposes.
+
+  No additional restrictions — You may not apply legal terms or
+  technological measures that legally restrict others from doing
+  anything the license permits.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode

package/README.md

@@ -0,0 +1,373 @@
+# @lagless/2d-map-generator
+
+Deterministic 2D map generator with feature-based architecture. Produces terrain, rivers, lakes, object placements, and ground patches from a single seed.
+
+## Quick Start
+
+```typescript
+import {
+  MapGenerator, BiomeFeature, ShoreFeature, GrassFeature,
+  SpatialGridCollisionProvider, ObjectPlacementFeature,
+  STANDARD_BIOME, PlacementKind, TerrainZone,
+  createMapColliders, CANOPY_SENSOR_TAG,
+} from '@lagless/2d-map-generator';
+import type { ObjectPlacementOutput } from '@lagless/2d-map-generator';
+
+// 1. Configure generator with your game's features
+const generator = new MapGenerator({ baseWidth: 720, baseHeight: 720, scale: 1, extension: 80, gridSize: 16 });
+generator
+  .addFeature(new BiomeFeature(), STANDARD_BIOME)
+  .addFeature(new ShoreFeature(), { inset: 48, divisions: 12, variation: 4 })
+  .addFeature(new GrassFeature(), { inset: 18, variation: 3 })
+  .addFeature(new ObjectPlacementFeature(), {
+    registry: myObjectRegistry,  // your game's object definitions
+    stages: [{ kind: PlacementKind.Density, typeId: 0, density: 100, terrainZone: TerrainZone.Grass }],
+  });
+
+// 2. Generate map (deterministic — same seed = same map)
+const collision = new SpatialGridCollisionProvider(1024, 1024, 64);
+const map = generator.generate(prng, collision);
+
+// 3. Access feature outputs (type-safe)
+const placement = map.get<ObjectPlacementOutput>(ObjectPlacementFeature);
+
+// 4. Create physics colliders from placed objects
+//    skipTags prevents creating physics bodies for sensor colliders (e.g. canopy zones)
+if (placement) {
+  createMapColliders(physicsAdapter, placement.objects, myObjectRegistry, {
+    skipTags: [CANOPY_SENSOR_TAG],
+  });
+}
+```
+
+> **Note:** Object definitions and generator presets are game-specific — define them in your game project, not in this library. See the [Object Definitions](#object-definitions) section for the `MapObjectDef` format.
+
+## Architecture
+
+```
+MapGenerator
+  ├── addFeature(feature, config)   // register features
+  └── generate(random, collision)   // run all features in dependency order
+        │
+        ├── BiomeFeature        → BiomeOutput (colors)
+        ├── ShoreFeature        → ShoreOutput (shore polygon)
+        ├── GrassFeature        → GrassOutput (grass polygon)
+        ├── RiverFeature        → RiverOutput (river polygons)
+        ├── LakeFeature         → LakeOutput (lake polygons)
+        ├── BridgeFeature       → BridgeOutput (bridge placements)
+        ├── ObjectPlacementFeature → ObjectPlacementOutput (placed objects)
+        ├── GroundPatchFeature  → GroundPatchOutput (ground patches)
+        └── PlacesFeature       → PlacesOutput (named positions)
+```
+
+Features declare dependencies via `requires`. The generator resolves them with topological sort — no manual ordering needed.
+
+## Custom Generator
+
+```typescript
+import {
+  MapGenerator, BiomeFeature, ShoreFeature, GrassFeature,
+  RiverFeature, ObjectPlacementFeature,
+  PlacementKind, TerrainZone,
+} from '@lagless/2d-map-generator';
+
+const generator = new MapGenerator({
+  baseWidth: 720,
+  baseHeight: 720,
+  scale: 1.0,
+  extension: 80,
+  gridSize: 16,
+});
+
+generator
+  .addFeature(new BiomeFeature(), {
+    background: 0x80af49,
+    water: 0x3d85c6,
+    waterRipple: 0x3478b2,
+    beach: 0xcdb35b,
+    riverbank: 0x905e24,
+    grass: 0x80af49,
+    underground: 0x1b0d00,
+  })
+  .addFeature(new ShoreFeature(), { inset: 48, divisions: 12, variation: 4 })
+  .addFeature(new GrassFeature(), { inset: 18, variation: 3 })
+  .addFeature(new RiverFeature(), {
+    weights: [
+      { weight: 0.25, widths: [8, 4] },
+      { weight: 0.75, widths: [4] },
+    ],
+    subdivisionPasses: 5,
+    masks: [],
+  })
+  .addFeature(new ObjectPlacementFeature(), {
+    registry: myObjectRegistry,
+    stages: [
+      { kind: PlacementKind.Density, typeId: 0, density: 100, terrainZone: TerrainZone.Grass },
+      { kind: PlacementKind.Fixed, typeId: 1, count: 10 },
+      { kind: PlacementKind.Location, typeId: 2, pos: { x: 100, y: 100 }, rad: 20, optional: true },
+    ],
+  });
+
+const map = generator.generate(random, collision);
+```
+
+## Object Definitions
+
+Objects are defined via `MapObjectDef` with separate collider and visual arrays:
+
+```typescript
+import { ShapeType, RenderLayer } from '@lagless/2d-map-generator';
+import type { MapObjectDef, MapObjectRegistry } from '@lagless/2d-map-generator';
+
+import { CANOPY_SENSOR_TAG } from '@lagless/2d-map-generator';
+
+const TREE: MapObjectDef = {
+  typeId: 0,
+  colliders: [
+    { shape: { type: ShapeType.Circle, radius: 3 } },
+    // Sensor collider for canopy transparency zone (view-only, skipped by createMapColliders via skipTags)
+    { shape: { type: ShapeType.Circle, radius: 128 }, isSensor: true, tag: CANOPY_SENSOR_TAG },
+  ],
+  visuals: [
+    { texture: 'tree-trunk', layer: RenderLayer.Ground },
+    { texture: 'tree-foliage', layer: RenderLayer.Canopy },
+  ],
+  scaleRange: [0.1, 0.2],
+};
+
+const BUILDING: MapObjectDef = {
+  typeId: 1,
+  colliders: [
+    { shape: { type: ShapeType.Cuboid, halfWidth: 10, halfHeight: 8 } },
+    { shape: { type: ShapeType.Circle, radius: 15 }, isSensor: true, tag: 1 },
+  ],
+  visuals: [
+    { texture: 'building-floor', layer: RenderLayer.Ground },
+    { texture: 'building-roof', layer: RenderLayer.Canopy },
+  ],
+  scaleRange: [1, 1],
+  groundPatches: [
+    {
+      offset: { x: 0, y: 0 },
+      halfExtents: { x: 12, y: 10 },
+      color: 0x8b4513,
+      roughness: 0.5,
+      offsetDist: 2,
+      order: 0,
+      useAsMapShape: false,
+    },
+  ],
+};
+
+const registry: MapObjectRegistry = new Map([
+  [0, TREE],
+  [1, BUILDING],
+]);
+```
+
+## Placement Stages
+
+| Kind | Description | Key Fields |
+|------|-------------|------------|
+| `PlacementKind.Location` | Place at specific position | `typeId`, `pos`, `rad`, `optional` |
+| `PlacementKind.Fixed` | Place exact count | `typeId`, `count`, `important?` |
+| `PlacementKind.Random` | Choose N from a list | `spawns: number[]`, `choose` |
+| `PlacementKind.Density` | Count proportional to map area | `typeId`, `density` |
+
+All stages support optional `terrainZone` to restrict placement to a terrain type.
+
+## Accessing Feature Outputs
+
+```typescript
+import {
+  BiomeFeature, ShoreFeature, GrassFeature,
+  RiverFeature, ObjectPlacementFeature,
+} from '@lagless/2d-map-generator';
+import type { BiomeOutput, ShoreOutput, ObjectPlacementOutput } from '@lagless/2d-map-generator';
+
+const map = generator.generate(random, collision);
+
+// Type-safe access via feature class:
+const biome = map.get<BiomeOutput>(BiomeFeature);
+const shore = map.get<ShoreOutput>(ShoreFeature);
+const placement = map.get<ObjectPlacementOutput>(ObjectPlacementFeature);
+```
+
+## Collision Providers
+
+Generation-time collision providers prevent object overlap during placement:
+
+```typescript
+import { SpatialGridCollisionProvider } from '@lagless/2d-map-generator';
+
+// Fast grid-based provider (recommended)
+const collision = new SpatialGridCollisionProvider(mapWidth, mapHeight, cellSize);
+const map = generator.generate(random, collision);
+```
+
+`RapierCollisionProvider` is also available for Rapier-based overlap testing.
+
+## Physics Integration
+
+`createMapColliders` converts placed objects into physics bodies via a `MapPhysicsProvider` adapter:
+
+```typescript
+import { createMapColliders, CANOPY_SENSOR_TAG } from '@lagless/2d-map-generator';
+import type { MapPhysicsProvider, CreateMapCollidersOptions } from '@lagless/2d-map-generator';
+
+// Implement the adapter for your physics engine:
+const physics: MapPhysicsProvider = {
+  createFixedBody(x, y, rotation) {
+    const desc = rapier.RigidBodyDesc.fixed().setTranslation(x, y).setRotation(rotation);
+    return worldManager.createBodyFromDesc(desc);
+  },
+  createCircleCollider(body, radius, ox, oy, isSensor, tag, collisionGroup) {
+    let desc = rapier.ColliderDesc.ball(radius).setTranslation(ox, oy).setSensor(isSensor);
+    if (collisionGroup != null) desc = desc.setCollisionGroups(collisionGroup);
+    worldManager.createColliderFromDesc(desc, body);
+  },
+  createCuboidCollider(body, hw, hh, ox, oy, isSensor, tag, collisionGroup) {
+    let desc = rapier.ColliderDesc.cuboid(hw, hh).setTranslation(ox, oy).setSensor(isSensor);
+    if (collisionGroup != null) desc = desc.setCollisionGroups(collisionGroup);
+    worldManager.createColliderFromDesc(desc, body);
+  },
+};
+
+// skipTags: skip colliders with matching tags (e.g. canopy sensors — view-only, no physics needed)
+createMapColliders(physics, placement.objects, registry, {
+  skipTags: [CANOPY_SENSOR_TAG],
+});
+```
+
+Handles circle/cuboid shapes, offset, scale, rotation, sensors, tags, collision groups, and recursive children.
+
+### Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `skipTags` | `readonly number[]` | Skip colliders whose `tag` is in this list. Use to prevent creating physics bodies for view-only sensors (e.g. `CANOPY_SENSOR_TAG`). |
+
+## Terrain Query
+
+Classify world positions into terrain zones:
+
+```typescript
+import { TerrainQuery, TerrainZone } from '@lagless/2d-map-generator';
+
+const terrain = new TerrainQuery({
+  shore: map.get<ShoreOutput>(ShoreFeature),
+  grass: map.get<GrassOutput>(GrassFeature),
+  river: map.get<RiverOutput>(RiverFeature),
+  lake: map.get<LakeOutput>(LakeFeature),
+});
+
+const zone = terrain.classify(x, y); // TerrainZone.Grass, .Beach, .River, etc.
+```
+
+## Utilities
+
+### sortPlacedObjects
+
+Sorts placed objects by position (Y then X). Used internally by both `MapObjectRenderer.build()` and `extractCanopyZones()` to guarantee consistent object indices.
+
+```typescript
+import { sortPlacedObjects } from '@lagless/2d-map-generator';
+
+const sorted = sortPlacedObjects(placement.objects);
+// sorted[i] index matches MapObjectRenderer particle index and CanopyZone.objectIndex
+```
+
+### extractCanopyZones
+
+Extracts canopy zone data from placed objects for view-layer distance checks. Returns pre-computed zones with squared radii for fast per-frame comparisons.
+
+```typescript
+import { extractCanopyZones, isInsideCanopyZone, CANOPY_SENSOR_TAG } from '@lagless/2d-map-generator';
+import type { CanopyZone } from '@lagless/2d-map-generator';
+
+const zones: CanopyZone[] = extractCanopyZones(placement.objects, registry);
+// Default tag = CANOPY_SENSOR_TAG. Custom: extractCanopyZones(objects, registry, myTag)
+
+// Two zone variants:
+// CanopyZoneCircle: { type: 'circle', x, y, radiusSq, objectIndex }
+// CanopyZoneCuboid: { type: 'cuboid', x, y, halfWidth, halfHeight, objectIndex }
+```
+
+**How it works:** Calls `sortPlacedObjects()` internally, iterates sorted objects, finds sensor colliders with matching `tag` and `isSensor: true`, extracts position + scaled dimensions. Supports both `ShapeType.Circle` and `ShapeType.Cuboid` sensors.
+
+### isInsideCanopyZone
+
+Checks whether a point is inside a canopy zone. Handles both circle and cuboid zone types:
+
+```typescript
+import { isInsideCanopyZone } from '@lagless/2d-map-generator';
+
+const inside = isInsideCanopyZone(zone, playerX, playerY); // true if inside
+```
+
+### CANOPY_SENSOR_TAG
+
+Constant (`= 1`) used as a tag on sensor colliders in object definitions to mark canopy transparency zones. Used by:
+- `extractCanopyZones()` — default tag parameter
+- `createMapColliders()` with `skipTags` — prevents creating physics bodies for canopy sensors
+
+## Rendering
+
+Use `@lagless/2d-map-renderer` for Pixi.js rendering:
+
+```typescript
+import { MapTerrainRenderer, MapObjectRenderer } from '@lagless/2d-map-renderer';
+
+// Terrain (shore, grass, rivers, lakes)
+const terrain = new MapTerrainRenderer();
+viewport.addChild(terrain.buildTerrain(map));
+
+// Objects (two ParticleContainers: ground + canopy)
+const objects = new MapObjectRenderer({ dynamicCanopyAlpha: true });
+objects.build(placement.objects, registry, (key) => Assets.get(key) ?? Texture.EMPTY);
+viewport.addChild(objects.ground);   // under entities
+viewport.addChild(objects.canopy);   // over entities
+
+// Canopy transparency — set alpha for a specific object by sorted index:
+objects.setCanopyAlpha(objectIndex, 0.3);  // transparent
+objects.setCanopyAlpha(objectIndex, 1.0);  // opaque
+```
+
+### Canopy Transparency (View-Layer Distance Checks)
+
+Canopy transparency is a **view-only** concern — it must NOT live in ECS or affect determinism. Use `extractCanopyZones()` to pre-compute zones once, then check distances per frame:
+
+```typescript
+import { extractCanopyZones, isInsideCanopyZone } from '@lagless/2d-map-generator';
+import type { ObjectPlacementOutput } from '@lagless/2d-map-generator';
+
+// Pre-compute once (e.g. in useMemo):
+const placement = map.get<ObjectPlacementOutput>(ObjectPlacementFeature);
+const canopyZones = placement ? extractCanopyZones(placement.objects, registry) : [];
+
+// Per frame (e.g. in useTick):
+const px = playerX, py = playerY;
+for (const zone of canopyZones) {
+  const inside = isInsideCanopyZone(zone, px, py);
+  objectRenderer.setCanopyAlpha(zone.objectIndex, inside ? 0.3 : 1.0);
+}
+```
+
+**Performance:** O(N) per frame with N ≈ 100-200 objects — just multiply + compare per object, negligible cost.
+
+## Determinism
+
+All generation is deterministic. Requirements:
+- Use `ISeededRandom` (ECS `PRNG` satisfies this structurally)
+- Trigonometry uses `MathOps` (WASM-backed, cross-platform identical)
+- Same seed + same config = identical map on every client
+
+## Enums
+
+| Enum | Values |
+|------|--------|
+| `ShapeType` | `Circle = 0`, `Cuboid = 1` |
+| `FeatureId` | `Biome = 0` through `Places = 8` |
+| `PlacementKind` | `Location = 0`, `Fixed = 1`, `Random = 2`, `Density = 3` |
+| `RenderLayer` | `Ground = 0`, `Canopy = 1` |
+| `TerrainZone` | `Grass = 0`, `Beach = 1`, `RiverShore = 2`, `River = 3`, `Lake = 4`, `Bridge = 5`, `WaterEdge = 6` |

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export * from './lib/types/index.js';
+export { GeneratedMap } from './lib/core/generated-map.js';
+export { MapGenerator } from './lib/core/map-generator.js';
+export { computeDimensions } from './lib/core/map-dimensions.js';
+export { generateJaggedAabbPoints } from './lib/math/jagged-aabb.js';
+export { pointInPolygon, polygonArea, distToSegmentSq, computePolygonBounds } from './lib/math/polygon-utils.js';
+export { testCircleCircle, testCircleAabb, testAabbAabb } from './lib/math/collision-test.js';
+export { BiomeFeature } from './lib/features/biome-feature.js';
+export { ShoreFeature } from './lib/features/shore-feature.js';
+export { GrassFeature } from './lib/features/grass-feature.js';
+export { SpatialGridCollisionProvider } from './lib/collision/spatial-grid-provider.js';
+export { catmullRom, catmullRomDerivative, getControlPoints } from './lib/math/catmull-rom.js';
+export { Spline } from './lib/math/spline.js';
+export { generateRiverPolygon } from './lib/math/river-polygon.js';
+export { RiverFeature } from './lib/features/river-feature.js';
+export { LakeFeature } from './lib/features/lake-feature.js';
+export { TerrainQuery } from './lib/core/terrain-query.js';
+export type { TerrainQueryInputs } from './lib/core/terrain-query.js';
+export { ObjectPlacementFeature } from './lib/features/object-placement-feature.js';
+export { GroundPatchFeature } from './lib/features/ground-patch-feature.js';
+export { BridgeFeature } from './lib/features/bridge-feature.js';
+export { RapierCollisionProvider } from './lib/collision/rapier-provider.js';
+export { PlacesFeature } from './lib/features/places-feature.js';
+export { STANDARD_BIOME } from './lib/presets/standard-biome.js';
+export { createMapColliders } from './lib/physics/create-map-colliders.js';
+export type { MapPhysicsProvider, CreateMapCollidersOptions } from './lib/physics/create-map-colliders.js';
+export { CANOPY_SENSOR_TAG } from './lib/physics/canopy-sensor-tag.js';
+export { sortPlacedObjects } from './lib/utils/sort-placed-objects.js';
+export { extractCanopyZones, isInsideCanopyZone } from './lib/utils/extract-canopy-zones.js';
+export type { CanopyZone, CanopyZoneCircle, CanopyZoneCuboid } from './lib/utils/extract-canopy-zones.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACjH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC/F,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,YAAY,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAC3G,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAC7F,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+export * from './lib/types/index.js';
+export { GeneratedMap } from './lib/core/generated-map.js';
+export { MapGenerator } from './lib/core/map-generator.js';
+export { computeDimensions } from './lib/core/map-dimensions.js';
+export { generateJaggedAabbPoints } from './lib/math/jagged-aabb.js';
+export { pointInPolygon, polygonArea, distToSegmentSq, computePolygonBounds } from './lib/math/polygon-utils.js';
+export { testCircleCircle, testCircleAabb, testAabbAabb } from './lib/math/collision-test.js';
+export { BiomeFeature } from './lib/features/biome-feature.js';
+export { ShoreFeature } from './lib/features/shore-feature.js';
+export { GrassFeature } from './lib/features/grass-feature.js';
+export { SpatialGridCollisionProvider } from './lib/collision/spatial-grid-provider.js';
+export { catmullRom, catmullRomDerivative, getControlPoints } from './lib/math/catmull-rom.js';
+export { Spline } from './lib/math/spline.js';
+export { generateRiverPolygon } from './lib/math/river-polygon.js';
+export { RiverFeature } from './lib/features/river-feature.js';
+export { LakeFeature } from './lib/features/lake-feature.js';
+export { TerrainQuery } from './lib/core/terrain-query.js';
+export { ObjectPlacementFeature } from './lib/features/object-placement-feature.js';
+export { GroundPatchFeature } from './lib/features/ground-patch-feature.js';
+export { BridgeFeature } from './lib/features/bridge-feature.js';
+export { RapierCollisionProvider } from './lib/collision/rapier-provider.js';
+export { PlacesFeature } from './lib/features/places-feature.js';
+export { STANDARD_BIOME } from './lib/presets/standard-biome.js';
+export { createMapColliders } from './lib/physics/create-map-colliders.js';
+export { CANOPY_SENSOR_TAG } from './lib/physics/canopy-sensor-tag.js';
+export { sortPlacedObjects } from './lib/utils/sort-placed-objects.js';
+export { extractCanopyZones, isInsideCanopyZone } from './lib/utils/extract-canopy-zones.js';

package/dist/lib/collision/rapier-provider.d.ts

@@ -0,0 +1,54 @@
+import type { ICollisionProvider } from '../types/collision-provider.js';
+import type { MapCollisionShape } from '../types/geometry.js';
+interface RapierVector2 {
+    x: number;
+    y: number;
+}
+interface RapierRigidBodyDesc {
+    setTranslation(x: number, y: number): RapierRigidBodyDesc;
+    setRotation(rotation: number): RapierRigidBodyDesc;
+}
+interface RapierRigidBody {
+    handle: number;
+}
+interface RapierWorld {
+    createRigidBody(desc: RapierRigidBodyDesc): RapierRigidBody;
+    createCollider(desc: RapierColliderDesc, body: RapierRigidBody): unknown;
+    removeRigidBody(body: RapierRigidBody): void;
+    getRigidBody(handle: number): RapierRigidBody | null;
+    intersectionsWithShape(pos: RapierVector2, rotation: number, shape: RapierShape, callback: (handle: number) => boolean): void;
+    step(): void;
+}
+interface RapierShape {
+    readonly __rapierShape?: unknown;
+}
+interface RapierColliderDesc {
+    readonly __rapierColliderDesc?: unknown;
+}
+export interface RapierModule2dLike {
+    Vector2: new (x: number, y: number) => RapierVector2;
+    World: new (gravity: RapierVector2) => RapierWorld;
+    RigidBodyDesc: {
+        fixed(): RapierRigidBodyDesc;
+    };
+    ColliderDesc: {
+        ball(radius: number): RapierColliderDesc;
+        cuboid(halfWidth: number, halfHeight: number): RapierColliderDesc;
+    };
+    Ball: new (radius: number) => RapierShape;
+    Cuboid: new (halfWidth: number, halfHeight: number) => RapierShape;
+}
+export declare class RapierCollisionProvider implements ICollisionProvider {
+    private readonly _rapier;
+    private _world;
+    private readonly _bodies;
+    constructor(rapier: RapierModule2dLike);
+    addShape(id: number, shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): void;
+    testShape(shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): boolean;
+    removeShape(id: number): void;
+    clear(): void;
+    private _createShape;
+    private _createColliderDesc;
+}
+export {};
+//# sourceMappingURL=rapier-provider.d.ts.map

package/dist/lib/collision/rapier-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rapier-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/collision/rapier-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,UAAU,aAAa;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,UAAU,mBAAmB;IAC3B,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAAC;IAC1D,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAAC;CACpD;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CAAC;IAC5D,cAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC;IACzE,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC7C,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IACrD,sBAAsB,CACpB,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EACxD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,GACpC,IAAI,CAAC;IACR,IAAI,IAAI,IAAI,CAAC;CACd;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;IACrD,KAAK,EAAE,KAAK,OAAO,EAAE,aAAa,KAAK,WAAW,CAAC;IACnD,aAAa,EAAE;QAAE,KAAK,IAAI,mBAAmB,CAAA;KAAE,CAAC;IAChD,YAAY,EAAE;QACZ,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC;QACzC,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAAC;KACnE,CAAC;IACF,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,WAAW,CAAC;IAC1C,MAAM,EAAE,KAAK,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,WAAW,CAAC;CACpE;AAED,qBAAa,uBAAwB,YAAW,kBAAkB;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;gBAE9C,MAAM,EAAE,kBAAkB;IAMtC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAajH,SAAS,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAiBzG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAW7B,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,mBAAmB;CAM5B"}

package/dist/lib/collision/rapier-provider.js

@@ -0,0 +1,67 @@
+import { ShapeType } from '../types/geometry.js';
+export class RapierCollisionProvider {
+    _rapier;
+    _world;
+    _bodies = new Map();
+    constructor(rapier) {
+        this._rapier = rapier;
+        const gravity = new rapier.Vector2(0, 0);
+        this._world = new rapier.World(gravity);
+    }
+    addShape(id, shape, posX, posY, rotation, scale) {
+        const colliderDesc = this._createColliderDesc(shape, scale);
+        if (!colliderDesc)
+            return;
+        const R = this._rapier;
+        const bodyDesc = R.RigidBodyDesc.fixed()
+            .setTranslation(posX, posY)
+            .setRotation(rotation);
+        const body = this._world.createRigidBody(bodyDesc);
+        this._world.createCollider(colliderDesc, body);
+        this._bodies.set(id, body.handle);
+    }
+    testShape(shape, posX, posY, rotation, scale) {
+        const rapierShape = this._createShape(shape, scale);
+        if (!rapierShape)
+            return false;
+        const position = new this._rapier.Vector2(posX, posY);
+        this._world.step();
+        let hasOverlap = false;
+        this._world.intersectionsWithShape(position, rotation, rapierShape, () => {
+            hasOverlap = true;
+            return false;
+        });
+        return hasOverlap;
+    }
+    removeShape(id) {
+        const handle = this._bodies.get(id);
+        if (handle === undefined)
+            return;
+        const body = this._world.getRigidBody(handle);
+        if (body) {
+            this._world.removeRigidBody(body);
+        }
+        this._bodies.delete(id);
+    }
+    clear() {
+        const gravity = new this._rapier.Vector2(0, 0);
+        this._world = new this._rapier.World(gravity);
+        this._bodies.clear();
+    }
+    _createShape(shape, scale) {
+        const R = this._rapier;
+        if (shape.type === ShapeType.Circle)
+            return new R.Ball(shape.radius * scale);
+        if (shape.type === ShapeType.Cuboid)
+            return new R.Cuboid(shape.halfWidth * scale, shape.halfHeight * scale);
+        return null;
+    }
+    _createColliderDesc(shape, scale) {
+        const R = this._rapier;
+        if (shape.type === ShapeType.Circle)
+            return R.ColliderDesc.ball(shape.radius * scale);
+        if (shape.type === ShapeType.Cuboid)
+            return R.ColliderDesc.cuboid(shape.halfWidth * scale, shape.halfHeight * scale);
+        return null;
+    }
+}

package/dist/lib/collision/spatial-grid-provider.d.ts

@@ -0,0 +1,19 @@
+import type { ICollisionProvider } from '../types/collision-provider.js';
+import type { MapCollisionShape } from '../types/geometry.js';
+export declare class SpatialGridCollisionProvider implements ICollisionProvider {
+    private readonly _cellSize;
+    private readonly _gridW;
+    private readonly _gridH;
+    private readonly _cells;
+    private readonly _shapes;
+    private _queryId;
+    private readonly _lastQueried;
+    constructor(width: number, height: number, cellSize?: number);
+    addShape(id: number, shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): void;
+    testShape(shape: MapCollisionShape, posX: number, posY: number, rotation: number, scale: number): boolean;
+    removeShape(id: number): void;
+    clear(): void;
+    private _createStoredShape;
+    private _testOverlap;
+}
+//# sourceMappingURL=spatial-grid-provider.d.ts.map

package/dist/lib/collision/spatial-grid-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-grid-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/collision/spatial-grid-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAiB9D,qBAAa,4BAA6B,YAAW,kBAAkB;IACrE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;gBAE9C,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAK;IAOxD,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAiBjH,SAAS,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IA4BzG,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAwB7B,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,kBAAkB;IA4B1B,OAAO,CAAC,YAAY;CAkCrB"}