@directivegames/genesys.sdk 3.2.2 → 3.2.5

package/src/templates/src/templates/sideScroller/src/level-generator.ts

@@ -1,361 +1,361 @@
-import * as ENGINE from 'genesys.js';
-import * as THREE from 'three';
-
-import { COLORS, LEVEL_CONFIG } from './const.js';
-
-// ============================================================================
-// LEVEL GENERATOR
-// ============================================================================
-
-// Interface for level generator configuration options
-interface LevelGeneratorOptions {
-  chunkSize?: number;
-  chunksAhead?: number;
-  chunksBehind?: number;
-  platformHeightRange?: { min: number; max: number };
-  platformWidthRange?: { min: number; max: number };
-  obstacleHeightRange?: { min: number; max: number };
-  chunkMargin?: number;
-  minSpacing?: number;
-  enableDebugVisualization?: boolean;
-  createGroundMesh?: boolean;
-}
-
-// Interface for tracking level chunks
-interface LevelChunk {
-  startX: number;
-  endX: number;
-  actors: ENGINE.Actor[];
-}
-
-// Interface for positioned elements within chunks
-interface PositionedElement {
-  x: number;
-  width: number;
-  height: number;
-  type: 'platform' | 'obstacle';
-}
-
-// Simple level generator for infinite side-scrolling levels
-export class SideScrollerLevelGenerator {
-  private world: ENGINE.World;
-  // Map of chunk index to chunk
-  private levelChunks: Map<number, LevelChunk> = new Map();
-
-  // Configuration
-  private chunkSize: number;
-  private chunksAhead: number;
-  private chunksBehind: number;
-  private platformHeightRange: { min: number; max: number };
-  private platformWidthRange: { min: number; max: number };
-  private obstacleHeightRange: { min: number; max: number };
-  private chunkMargin: number;
-  private minSpacing: number;
-  private debugVisualizationEnabled: boolean = false;
-  private createGroundMesh: boolean = false;
-
-  constructor(world: ENGINE.World, options: LevelGeneratorOptions = {}) {
-    this.world = world;
-
-    // Apply defaults
-    this.chunkSize = options.chunkSize ?? LEVEL_CONFIG.CHUNK_SIZE;
-    this.chunksAhead = options.chunksAhead ?? LEVEL_CONFIG.CHUNKS_AHEAD;
-    this.chunksBehind = options.chunksBehind ?? LEVEL_CONFIG.CHUNKS_BEHIND;
-    this.platformHeightRange = options.platformHeightRange ?? LEVEL_CONFIG.PLATFORM_HEIGHT_RANGE;
-    this.platformWidthRange = options.platformWidthRange ?? LEVEL_CONFIG.PLATFORM_WIDTH_RANGE;
-    this.obstacleHeightRange = options.obstacleHeightRange ?? LEVEL_CONFIG.OBSTACLE_HEIGHT_RANGE;
-    this.chunkMargin = options.chunkMargin ?? LEVEL_CONFIG.CHUNK_MARGIN;
-    this.minSpacing = options.minSpacing ?? LEVEL_CONFIG.MIN_SPACING;
-    this.debugVisualizationEnabled = options.enableDebugVisualization ?? false;
-    this.createGroundMesh = options.createGroundMesh ?? false;
-  }
-
-  public updateLevel(playerX: number): void {
-    const playerChunkIndex = this.getChunkIndex(playerX);
-
-    const validChunkIndices = [];
-    for (let i = playerChunkIndex - this.chunksBehind; i <= playerChunkIndex + this.chunksAhead; i++) {
-      this.generateChunk(i);
-      validChunkIndices.push(i);
-    }
-
-    for (const index of this.levelChunks.keys()) {
-      if (!validChunkIndices.includes(index)) {
-        this.removeChunk(index);
-      }
-    }
-  }
-
-  private getChunkIndex(x: number): number {
-    return Math.floor(x / this.chunkSize);
-  }
-
-  private removeChunk(index: number): void {
-    const chunk = this.levelChunks.get(index);
-    if (chunk) {
-      this.world.removeActors(...chunk.actors);
-      this.levelChunks.delete(index);
-      console.log(`[LevelGenerator] Removed chunk at index ${index}`);
-    }
-  }
-
-  private generateChunk(index: number): void {
-    if (this.levelChunks.has(index)) {
-      return;
-    }
-
-    const startX = index * this.chunkSize;
-    const endX = startX + this.chunkSize;
-    const actors: ENGINE.Actor[] = [];
-
-    // Generate positioned elements for this chunk
-    const elements = this.generatePositionedElements(startX);
-
-    // Create actors for each element
-    for (const element of elements) {
-      const actor = this.createElementActor(element);
-      actors.push(actor);
-    }
-
-    // Add ground mesh if enabled
-    if (this.createGroundMesh) {
-      const groundActor = this.createGroundMeshActor(startX);
-      actors.push(groundActor);
-    }
-
-    // Add debug visualization if enabled
-    if (this.debugVisualizationEnabled) {
-      const debugActor = this.createChunkDebugVisualization(startX);
-      actors.push(debugActor);
-    }
-
-    // Add all actors to the world
-    this.world.addActors(...actors);
-
-    // Track this chunk
-    const chunk: LevelChunk = {
-      startX,
-      endX,
-      actors,
-    };
-    console.log(`[LevelGenerator] Generated chunk at index ${index}`);
-    this.levelChunks.set(index, chunk);
-  }
-
-  private generatePositionedElements(startX: number): PositionedElement[] {
-    const elements: PositionedElement[] = [];
-    const usableWidth = this.chunkSize - (this.chunkMargin * 2); // Leave margin on each side
-    const usableStartX = startX + this.chunkMargin;
-
-    // Simple alternating generation: platform -> obstacle -> platform -> obstacle...
-    const totalElements = Math.floor(usableWidth / this.minSpacing); // How many elements can fit
-
-    let currentX = usableStartX;
-    let isPlatform = true; // Start with platform
-
-    for (let i = 0; i < totalElements && currentX < (startX + this.chunkSize - this.chunkMargin); i++) {
-      if (isPlatform) {
-        // Generate platform with random dimensions
-        const width = this.platformWidthRange.min +
-          Math.random() * (this.platformWidthRange.max - this.platformWidthRange.min);
-        const height = this.platformHeightRange.min +
-          Math.random() * (this.platformHeightRange.max - this.platformHeightRange.min);
-
-        elements.push({
-          x: currentX + width / 2, // Center position
-          width: width,
-          height: height,
-          type: 'platform'
-        });
-
-        currentX += width + this.minSpacing; // Move past this platform plus spacing
-
-      } else {
-        // Generate obstacle with random dimensions
-        const width = LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min +
-          Math.random() * (LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.max - LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min);
-        const height = this.obstacleHeightRange.min +
-          Math.random() * (this.obstacleHeightRange.max - this.obstacleHeightRange.min);
-
-        elements.push({
-          x: currentX + width / 2, // Center position
-          width: width,
-          height: height,
-          type: 'obstacle'
-        });
-
-        currentX += width + this.minSpacing; // Move past this obstacle plus spacing
-      }
-
-      // Alternate between platform and obstacle
-      isPlatform = !isPlatform;
-    }
-
-    return elements;
-  }
-
-  private createElementActor(element: PositionedElement): ENGINE.Actor {
-    const geometry = new THREE.BoxGeometry(element.width, element.height, LEVEL_CONFIG.DEPTH);
-    const material = new THREE.MeshStandardMaterial({ color: element.type === 'platform' ? COLORS.PLATFORM : COLORS.OBSTACLE });
-
-    const meshComponent = new ENGINE.MeshComponent({
-      geometry: geometry,
-      material: material,
-      position: new THREE.Vector3(element.x, element.height / 2, 0), // Position at ground level
-      physicsOptions: {
-        enabled: true,
-        motionType: ENGINE.PhysicsMotionType.Static,
-        collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
-      },
-    });
-
-    // Enable shadow casting and receiving
-    meshComponent.castShadow = true;
-    meshComponent.receiveShadow = true;
-
-    return new ENGINE.Actor({
-      rootComponent: meshComponent,
-    });
-  }
-
-  private createChunkDebugVisualization(startX: number): ENGINE.Actor {
-    // Create a wireframe box to visualize chunk boundaries
-    const chunkGeometry = new THREE.BoxGeometry(
-      this.chunkSize,
-      LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT,
-      LEVEL_CONFIG.DEPTH
-    );
-
-    const chunkMaterial = new THREE.MeshBasicMaterial({
-      color: LEVEL_CONFIG.DEBUG_VISUALIZATION_COLOR,
-      opacity: LEVEL_CONFIG.DEBUG_VISUALIZATION_OPACITY,
-      wireframe: true,
-      transparent: true,
-    });
-
-    const chunkBoundary = new ENGINE.Actor({
-      rootComponent: new ENGINE.MeshComponent({
-        geometry: chunkGeometry,
-        material: chunkMaterial,
-        position: new THREE.Vector3(
-          startX + this.chunkSize / 2,
-          LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT / 2,
-          0
-        ),
-        physicsOptions: {
-          enabled: false,
-        },
-      }),
-    });
-
-    return chunkBoundary;
-  }
-
-  private createGroundMeshActor(startX: number): ENGINE.Actor {
-    // Create a ground mesh that spans the entire chunk width
-    const groundGeometry = new THREE.BoxGeometry(
-      this.chunkSize,
-      LEVEL_CONFIG.GROUND_HEIGHT,
-      LEVEL_CONFIG.DEPTH
-    );
-
-    const groundMaterial = new THREE.MeshStandardMaterial({
-      color: COLORS.GROUND,
-    });
-
-    const groundMeshComponent = new ENGINE.MeshComponent({
-      geometry: groundGeometry,
-      material: groundMaterial,
-      position: new THREE.Vector3(
-        startX + this.chunkSize / 2,
-        LEVEL_CONFIG.GROUND_Y_POSITION,
-        0
-      ),
-      physicsOptions: {
-        enabled: true,
-        motionType: ENGINE.PhysicsMotionType.Static,
-        collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
-      },
-    });
-
-    // Enable shadow receiving
-    groundMeshComponent.receiveShadow = true;
-
-    return new ENGINE.Actor({
-      rootComponent: groundMeshComponent,
-    });
-  }
-
-  /**
-   * Gets detailed geometry information at a given x location.
-   * @param x - The x coordinate to query
-   * @returns An array of geometry info objects at the given x location
-   */
-  public getGeometryInfoAtX(x: number): Array<{
-    type: 'ground' | 'platform' | 'obstacle';
-    topY: number;
-    bottomY: number;
-    width: number;
-    centerX: number;
-  }> {
-    const chunkIndex = this.getChunkIndex(x);
-    const chunk = this.levelChunks.get(chunkIndex);
-
-    if (!chunk) {
-      return [];
-    }
-
-    const geometries: Array<{
-      type: 'ground' | 'platform' | 'obstacle';
-      topY: number;
-      bottomY: number;
-      width: number;
-      centerX: number;
-    }> = [];
-
-    // Add ground mesh if enabled
-    if (this.createGroundMesh) {
-      const groundCenterY = LEVEL_CONFIG.GROUND_Y_POSITION;
-      const groundHalfHeight = LEVEL_CONFIG.GROUND_HEIGHT / 2;
-      geometries.push({
-        type: 'ground',
-        topY: groundCenterY + groundHalfHeight,
-        bottomY: groundCenterY - groundHalfHeight,
-        width: this.chunkSize,
-        centerX: chunk.startX + this.chunkSize / 2
-      });
-    }
-
-    // Add positioned elements (platforms and obstacles)
-    const elements = this.generatePositionedElements(chunk.startX);
-
-    for (const element of elements) {
-      const elementLeft = element.x - element.width / 2;
-      const elementRight = element.x + element.width / 2;
-
-      // Check if the x coordinate falls within this element's bounds
-      if (x >= elementLeft && x <= elementRight) {
-        geometries.push({
-          type: element.type,
-          topY: element.height,
-          bottomY: 0, // Elements are positioned at ground level (y=0 bottom)
-          width: element.width,
-          centerX: element.x
-        });
-      }
-    }
-
-    // Sort by top height (highest first)
-    geometries.sort((a, b) => b.topY - a.topY);
-
-    return geometries;
-  }
-
-  public cleanup(): void {
-    for (const index of this.levelChunks.keys()) {
-      this.removeChunk(index);
-    }
-    this.levelChunks.clear();
-    console.log('[LevelGenerator] Cleaned up');
-  }
-}
+import * as ENGINE from '@directivegames/genesys.js';
+import * as THREE from 'three';
+
+import { COLORS, LEVEL_CONFIG } from './const.js';
+
+// ============================================================================
+// LEVEL GENERATOR
+// ============================================================================
+
+// Interface for level generator configuration options
+interface LevelGeneratorOptions {
+  chunkSize?: number;
+  chunksAhead?: number;
+  chunksBehind?: number;
+  platformHeightRange?: { min: number; max: number };
+  platformWidthRange?: { min: number; max: number };
+  obstacleHeightRange?: { min: number; max: number };
+  chunkMargin?: number;
+  minSpacing?: number;
+  enableDebugVisualization?: boolean;
+  createGroundMesh?: boolean;
+}
+
+// Interface for tracking level chunks
+interface LevelChunk {
+  startX: number;
+  endX: number;
+  actors: ENGINE.Actor[];
+}
+
+// Interface for positioned elements within chunks
+interface PositionedElement {
+  x: number;
+  width: number;
+  height: number;
+  type: 'platform' | 'obstacle';
+}
+
+// Simple level generator for infinite side-scrolling levels
+export class SideScrollerLevelGenerator {
+  private world: ENGINE.World;
+  // Map of chunk index to chunk
+  private levelChunks: Map<number, LevelChunk> = new Map();
+
+  // Configuration
+  private chunkSize: number;
+  private chunksAhead: number;
+  private chunksBehind: number;
+  private platformHeightRange: { min: number; max: number };
+  private platformWidthRange: { min: number; max: number };
+  private obstacleHeightRange: { min: number; max: number };
+  private chunkMargin: number;
+  private minSpacing: number;
+  private debugVisualizationEnabled: boolean = false;
+  private createGroundMesh: boolean = false;
+
+  constructor(world: ENGINE.World, options: LevelGeneratorOptions = {}) {
+    this.world = world;
+
+    // Apply defaults
+    this.chunkSize = options.chunkSize ?? LEVEL_CONFIG.CHUNK_SIZE;
+    this.chunksAhead = options.chunksAhead ?? LEVEL_CONFIG.CHUNKS_AHEAD;
+    this.chunksBehind = options.chunksBehind ?? LEVEL_CONFIG.CHUNKS_BEHIND;
+    this.platformHeightRange = options.platformHeightRange ?? LEVEL_CONFIG.PLATFORM_HEIGHT_RANGE;
+    this.platformWidthRange = options.platformWidthRange ?? LEVEL_CONFIG.PLATFORM_WIDTH_RANGE;
+    this.obstacleHeightRange = options.obstacleHeightRange ?? LEVEL_CONFIG.OBSTACLE_HEIGHT_RANGE;
+    this.chunkMargin = options.chunkMargin ?? LEVEL_CONFIG.CHUNK_MARGIN;
+    this.minSpacing = options.minSpacing ?? LEVEL_CONFIG.MIN_SPACING;
+    this.debugVisualizationEnabled = options.enableDebugVisualization ?? false;
+    this.createGroundMesh = options.createGroundMesh ?? false;
+  }
+
+  public updateLevel(playerX: number): void {
+    const playerChunkIndex = this.getChunkIndex(playerX);
+
+    const validChunkIndices = [];
+    for (let i = playerChunkIndex - this.chunksBehind; i <= playerChunkIndex + this.chunksAhead; i++) {
+      this.generateChunk(i);
+      validChunkIndices.push(i);
+    }
+
+    for (const index of this.levelChunks.keys()) {
+      if (!validChunkIndices.includes(index)) {
+        this.removeChunk(index);
+      }
+    }
+  }
+
+  private getChunkIndex(x: number): number {
+    return Math.floor(x / this.chunkSize);
+  }
+
+  private removeChunk(index: number): void {
+    const chunk = this.levelChunks.get(index);
+    if (chunk) {
+      this.world.removeActors(...chunk.actors);
+      this.levelChunks.delete(index);
+      console.log(`[LevelGenerator] Removed chunk at index ${index}`);
+    }
+  }
+
+  private generateChunk(index: number): void {
+    if (this.levelChunks.has(index)) {
+      return;
+    }
+
+    const startX = index * this.chunkSize;
+    const endX = startX + this.chunkSize;
+    const actors: ENGINE.Actor[] = [];
+
+    // Generate positioned elements for this chunk
+    const elements = this.generatePositionedElements(startX);
+
+    // Create actors for each element
+    for (const element of elements) {
+      const actor = this.createElementActor(element);
+      actors.push(actor);
+    }
+
+    // Add ground mesh if enabled
+    if (this.createGroundMesh) {
+      const groundActor = this.createGroundMeshActor(startX);
+      actors.push(groundActor);
+    }
+
+    // Add debug visualization if enabled
+    if (this.debugVisualizationEnabled) {
+      const debugActor = this.createChunkDebugVisualization(startX);
+      actors.push(debugActor);
+    }
+
+    // Add all actors to the world
+    this.world.addActors(...actors);
+
+    // Track this chunk
+    const chunk: LevelChunk = {
+      startX,
+      endX,
+      actors,
+    };
+    console.log(`[LevelGenerator] Generated chunk at index ${index}`);
+    this.levelChunks.set(index, chunk);
+  }
+
+  private generatePositionedElements(startX: number): PositionedElement[] {
+    const elements: PositionedElement[] = [];
+    const usableWidth = this.chunkSize - (this.chunkMargin * 2); // Leave margin on each side
+    const usableStartX = startX + this.chunkMargin;
+
+    // Simple alternating generation: platform -> obstacle -> platform -> obstacle...
+    const totalElements = Math.floor(usableWidth / this.minSpacing); // How many elements can fit
+
+    let currentX = usableStartX;
+    let isPlatform = true; // Start with platform
+
+    for (let i = 0; i < totalElements && currentX < (startX + this.chunkSize - this.chunkMargin); i++) {
+      if (isPlatform) {
+        // Generate platform with random dimensions
+        const width = this.platformWidthRange.min +
+          Math.random() * (this.platformWidthRange.max - this.platformWidthRange.min);
+        const height = this.platformHeightRange.min +
+          Math.random() * (this.platformHeightRange.max - this.platformHeightRange.min);
+
+        elements.push({
+          x: currentX + width / 2, // Center position
+          width: width,
+          height: height,
+          type: 'platform'
+        });
+
+        currentX += width + this.minSpacing; // Move past this platform plus spacing
+
+      } else {
+        // Generate obstacle with random dimensions
+        const width = LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min +
+          Math.random() * (LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.max - LEVEL_CONFIG.OBSTACLE_WIDTH_RANGE.min);
+        const height = this.obstacleHeightRange.min +
+          Math.random() * (this.obstacleHeightRange.max - this.obstacleHeightRange.min);
+
+        elements.push({
+          x: currentX + width / 2, // Center position
+          width: width,
+          height: height,
+          type: 'obstacle'
+        });
+
+        currentX += width + this.minSpacing; // Move past this obstacle plus spacing
+      }
+
+      // Alternate between platform and obstacle
+      isPlatform = !isPlatform;
+    }
+
+    return elements;
+  }
+
+  private createElementActor(element: PositionedElement): ENGINE.Actor {
+    const geometry = new THREE.BoxGeometry(element.width, element.height, LEVEL_CONFIG.DEPTH);
+    const material = new THREE.MeshStandardMaterial({ color: element.type === 'platform' ? COLORS.PLATFORM : COLORS.OBSTACLE });
+
+    const meshComponent = new ENGINE.MeshComponent({
+      geometry: geometry,
+      material: material,
+      position: new THREE.Vector3(element.x, element.height / 2, 0), // Position at ground level
+      physicsOptions: {
+        enabled: true,
+        motionType: ENGINE.PhysicsMotionType.Static,
+        collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
+      },
+    });
+
+    // Enable shadow casting and receiving
+    meshComponent.castShadow = true;
+    meshComponent.receiveShadow = true;
+
+    return new ENGINE.Actor({
+      rootComponent: meshComponent,
+    });
+  }
+
+  private createChunkDebugVisualization(startX: number): ENGINE.Actor {
+    // Create a wireframe box to visualize chunk boundaries
+    const chunkGeometry = new THREE.BoxGeometry(
+      this.chunkSize,
+      LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT,
+      LEVEL_CONFIG.DEPTH
+    );
+
+    const chunkMaterial = new THREE.MeshBasicMaterial({
+      color: LEVEL_CONFIG.DEBUG_VISUALIZATION_COLOR,
+      opacity: LEVEL_CONFIG.DEBUG_VISUALIZATION_OPACITY,
+      wireframe: true,
+      transparent: true,
+    });
+
+    const chunkBoundary = new ENGINE.Actor({
+      rootComponent: new ENGINE.MeshComponent({
+        geometry: chunkGeometry,
+        material: chunkMaterial,
+        position: new THREE.Vector3(
+          startX + this.chunkSize / 2,
+          LEVEL_CONFIG.DEBUG_VISUALIZATION_HEIGHT / 2,
+          0
+        ),
+        physicsOptions: {
+          enabled: false,
+        },
+      }),
+    });
+
+    return chunkBoundary;
+  }
+
+  private createGroundMeshActor(startX: number): ENGINE.Actor {
+    // Create a ground mesh that spans the entire chunk width
+    const groundGeometry = new THREE.BoxGeometry(
+      this.chunkSize,
+      LEVEL_CONFIG.GROUND_HEIGHT,
+      LEVEL_CONFIG.DEPTH
+    );
+
+    const groundMaterial = new THREE.MeshStandardMaterial({
+      color: COLORS.GROUND,
+    });
+
+    const groundMeshComponent = new ENGINE.MeshComponent({
+      geometry: groundGeometry,
+      material: groundMaterial,
+      position: new THREE.Vector3(
+        startX + this.chunkSize / 2,
+        LEVEL_CONFIG.GROUND_Y_POSITION,
+        0
+      ),
+      physicsOptions: {
+        enabled: true,
+        motionType: ENGINE.PhysicsMotionType.Static,
+        collisionProfile: ENGINE.DefaultCollisionProfile.BlockAll,
+      },
+    });
+
+    // Enable shadow receiving
+    groundMeshComponent.receiveShadow = true;
+
+    return new ENGINE.Actor({
+      rootComponent: groundMeshComponent,
+    });
+  }
+
+  /**
+   * Gets detailed geometry information at a given x location.
+   * @param x - The x coordinate to query
+   * @returns An array of geometry info objects at the given x location
+   */
+  public getGeometryInfoAtX(x: number): Array<{
+    type: 'ground' | 'platform' | 'obstacle';
+    topY: number;
+    bottomY: number;
+    width: number;
+    centerX: number;
+  }> {
+    const chunkIndex = this.getChunkIndex(x);
+    const chunk = this.levelChunks.get(chunkIndex);
+
+    if (!chunk) {
+      return [];
+    }
+
+    const geometries: Array<{
+      type: 'ground' | 'platform' | 'obstacle';
+      topY: number;
+      bottomY: number;
+      width: number;
+      centerX: number;
+    }> = [];
+
+    // Add ground mesh if enabled
+    if (this.createGroundMesh) {
+      const groundCenterY = LEVEL_CONFIG.GROUND_Y_POSITION;
+      const groundHalfHeight = LEVEL_CONFIG.GROUND_HEIGHT / 2;
+      geometries.push({
+        type: 'ground',
+        topY: groundCenterY + groundHalfHeight,
+        bottomY: groundCenterY - groundHalfHeight,
+        width: this.chunkSize,
+        centerX: chunk.startX + this.chunkSize / 2
+      });
+    }
+
+    // Add positioned elements (platforms and obstacles)
+    const elements = this.generatePositionedElements(chunk.startX);
+
+    for (const element of elements) {
+      const elementLeft = element.x - element.width / 2;
+      const elementRight = element.x + element.width / 2;
+
+      // Check if the x coordinate falls within this element's bounds
+      if (x >= elementLeft && x <= elementRight) {
+        geometries.push({
+          type: element.type,
+          topY: element.height,
+          bottomY: 0, // Elements are positioned at ground level (y=0 bottom)
+          width: element.width,
+          centerX: element.x
+        });
+      }
+    }
+
+    // Sort by top height (highest first)
+    geometries.sort((a, b) => b.topY - a.topY);
+
+    return geometries;
+  }
+
+  public cleanup(): void {
+    for (const index of this.levelChunks.keys()) {
+      this.removeChunk(index);
+    }
+    this.levelChunks.clear();
+    console.log('[LevelGenerator] Cleaned up');
+  }
+}