pixelweaver 0.1.0

package/src/lib/leveleditor/level-editor-commands.ts

@@ -0,0 +1,353 @@
+/**
+ * Level Editor Commands Plugin -- registers tile operations as undoable commands.
+ *
+ * Each command snapshots the previous tile at the target cell so that undo
+ * can restore it. The map-state module is imported directly (module-level
+ * singleton), following the same pattern as layer-commands.ts.
+ */
+
+import type { PluginModule } from '../core/plugin-loader.js';
+import {
+  mapState,
+  type TilePlacement,
+  type EntityPlacement,
+  type CollisionShape,
+} from './map-state.svelte.js';
+
+// --- Helpers ---
+
+/** Create the tile lookup key from column and row (mirrors map-state's internal tileKey). */
+function tileKey(col: number, row: number): string {
+  return `${String(col)},${String(row)}`;
+}
+
+/** Read the current tile at (col, row) from a layer, or null if empty. */
+function getTile(layerId: string, col: number, row: number): TilePlacement | null {
+  const layer = mapState.layers.find((l) => l.id === layerId);
+  if (!layer || layer.type !== 'tile' || !layer.tiles) return null;
+  return layer.tiles.get(tileKey(col, row)) ?? null;
+}
+
+// --- Snapshot types ---
+
+type PlaceTileSnapshot = { previous: TilePlacement | null };
+type RemoveTileSnapshot = { previous: TilePlacement | null };
+
+/** Stores the ID assigned by addEntity so undo can remove it. */
+type PlaceEntitySnapshot = { entityId: string };
+/** Stores the full entity data so undo can restore it. */
+type RemoveEntitySnapshot = { entity: EntityPlacement };
+/** Stores old position so undo can move it back. */
+type MoveEntitySnapshot = { oldX: number; oldY: number };
+/** Stores old properties so undo can restore them. */
+type UpdateEntityPropsSnapshot = { oldProperties: Record<string, string> };
+
+/** Stores the original fromIndex so undo can reverse the move. */
+type MoveLayerSnapshot = { fromIndex: number; toIndex: number };
+
+/** Stores the ID assigned by addCollisionShape so undo can remove it. */
+type AddCollisionSnapshot = { shapeId: string };
+/** Stores the full shape data so undo can restore it. */
+type RemoveCollisionSnapshot = { shape: CollisionShape };
+
+// --- Plugin ---
+
+export const levelEditorCommandsPlugin: PluginModule = {
+  name: 'leveleditor/commands',
+  version: '1.0.0',
+  description: 'Undoable tile, entity, and collision commands for the level editor',
+  dependencies: [],
+
+  register(api) {
+    // --- place_tile ---
+    api.addCommand('place_tile', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const col = params['col'];
+        const row = params['row'];
+        const tile = params['tile'] as TilePlacement;
+
+        // Snapshot whatever was at this cell before (null if empty).
+        const previous = getTile(layerId, col, row);
+        const snapshot: PlaceTileSnapshot = {
+          previous: previous ? { ...previous } : null,
+        };
+
+        mapState.placeTile(layerId, col, row, tile);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const col = params['col'];
+        const row = params['row'];
+        const typed = snapshot as PlaceTileSnapshot | undefined;
+
+        if (typed?.previous) {
+          mapState.placeTile(layerId, col, row, typed.previous);
+        } else {
+          mapState.removeTile(layerId, col, row);
+        }
+      },
+      describe(params) {
+        return `Placed tile at (${String(params['col'])}, ${String(params['row'])})`;
+      },
+    });
+
+    // --- remove_tile ---
+    api.addCommand('remove_tile', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const col = params['col'];
+        const row = params['row'];
+
+        // Snapshot the tile being removed (null if already empty).
+        const previous = getTile(layerId, col, row);
+        const snapshot: RemoveTileSnapshot = {
+          previous: previous ? { ...previous } : null,
+        };
+
+        mapState.removeTile(layerId, col, row);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const col = params['col'];
+        const row = params['row'];
+        const typed = snapshot as RemoveTileSnapshot | undefined;
+
+        if (typed?.previous) {
+          mapState.placeTile(layerId, col, row, typed.previous);
+        }
+        // If previous was null, the cell was already empty -- nothing to restore.
+      },
+      describe(params) {
+        return `Removed tile at (${String(params['col'])}, ${String(params['row'])})`;
+      },
+    });
+
+    // --- move_layer ---
+    api.addCommand('move_layer', {
+      tier: 'project',
+      execute(params) {
+        const fromIndex: number = params['fromIndex'];
+        const toIndex: number = params['toIndex'];
+
+        const snapshot: MoveLayerSnapshot = { fromIndex, toIndex };
+        mapState.moveLayer(fromIndex, toIndex);
+        return snapshot;
+      },
+      undo(_params, _ctx, snapshot) {
+        const typed = snapshot as MoveLayerSnapshot | undefined;
+        if (typed) {
+          // Reverse the move: what went from->to now goes to->from.
+          mapState.moveLayer(typed.toIndex, typed.fromIndex);
+        }
+      },
+      describe(params) {
+        return `Moved layer from index ${String(params['fromIndex'])} to ${String(params['toIndex'])}`;
+      },
+    });
+
+    // --- place_entity ---
+    api.addCommand('place_entity', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const projectRef = params['projectRef'];
+        const canvasRef = params['canvasRef'];
+        const x = params['x'];
+        const y = params['y'];
+        const height = params['height'] ?? 0;
+        const properties = params['properties'] ?? {};
+
+        const entity = mapState.addEntity(layerId, {
+          projectRef,
+          canvasRef,
+          x,
+          y,
+          height,
+          properties,
+        });
+        const snapshot: PlaceEntitySnapshot = { entityId: entity.id };
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const typed = snapshot as PlaceEntitySnapshot | undefined;
+        if (typed) {
+          mapState.removeEntity(layerId, typed.entityId);
+        }
+      },
+      describe(params) {
+        return `Placed entity at (${String(params['x'])}, ${String(params['y'])})`;
+      },
+    });
+
+    // --- remove_entity ---
+    api.addCommand('remove_entity', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const entityId = params['entityId'];
+
+        const entity = mapState.getEntity(layerId, entityId);
+        if (!entity) {
+          throw new Error(`Entity "${entityId}" not found on layer "${layerId}"`);
+        }
+        // Deep-copy the entity so the snapshot survives removal.
+        const snapshot: RemoveEntitySnapshot = {
+          entity: { ...entity, properties: { ...entity.properties } },
+        };
+
+        mapState.removeEntity(layerId, entityId);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const typed = snapshot as RemoveEntitySnapshot | undefined;
+        if (typed) {
+          // Restore the entity with its original ID intact.
+          mapState.restoreEntity(layerId, typed.entity);
+        }
+      },
+      describe() {
+        return 'Removed entity';
+      },
+    });
+
+    // --- move_entity ---
+    api.addCommand('move_entity', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const entityId = params['entityId'];
+        const x = params['x'];
+        const y = params['y'];
+
+        // Prefer oldX/oldY from params (set by viewport drag) because by the
+        // time execute runs, the entity's position has already been mutated for
+        // smooth visual feedback during drag. Fall back to entity state for
+        // non-drag callers.
+        let oldX = params['oldX'];
+        let oldY = params['oldY'];
+        if (oldX == null || oldY == null) {
+          const entity = mapState.getEntity(layerId, entityId);
+          if (!entity) {
+            throw new Error(`Entity "${entityId}" not found on layer "${layerId}"`);
+          }
+          oldX = entity.x;
+          oldY = entity.y;
+        }
+        const snapshot: MoveEntitySnapshot = { oldX, oldY };
+
+        mapState.moveEntity(layerId, entityId, x, y);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const entityId = params['entityId'];
+        const typed = snapshot as MoveEntitySnapshot | undefined;
+        if (typed) {
+          mapState.moveEntity(layerId, entityId, typed.oldX, typed.oldY);
+        }
+      },
+      describe(params) {
+        return `Moved entity to (${String(params['x'])}, ${String(params['y'])})`;
+      },
+    });
+
+    // --- update_entity_properties ---
+    api.addCommand('update_entity_properties', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const entityId = params['entityId'];
+        const properties = params['properties'];
+
+        const entity = mapState.getEntity(layerId, entityId);
+        if (!entity) {
+          throw new Error(`Entity "${entityId}" not found on layer "${layerId}"`);
+        }
+        const snapshot: UpdateEntityPropsSnapshot = {
+          oldProperties: { ...entity.properties },
+        };
+
+        mapState.updateEntityProperties(layerId, entityId, properties);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const entityId = params['entityId'];
+        const typed = snapshot as UpdateEntityPropsSnapshot | undefined;
+        if (typed) {
+          // Full replacement: overwrite current properties with the snapshot.
+          const entity = mapState.getEntity(layerId, entityId);
+          if (entity) {
+            entity.properties = { ...typed.oldProperties };
+          }
+        }
+      },
+      describe() {
+        return 'Updated entity properties';
+      },
+    });
+
+    // --- add_collision_shape ---
+    api.addCommand('add_collision_shape', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const type = params['type'];
+        const points = params['points'];
+
+        const shape = mapState.addCollisionShape(layerId, { type, points });
+        const snapshot: AddCollisionSnapshot = { shapeId: shape.id };
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const typed = snapshot as AddCollisionSnapshot | undefined;
+        if (typed) {
+          mapState.removeCollisionShape(layerId, typed.shapeId);
+        }
+      },
+      describe(params) {
+        return `Added collision ${String(params['type'])}`;
+      },
+    });
+
+    // --- remove_collision_shape ---
+    api.addCommand('remove_collision_shape', {
+      tier: 'project',
+      execute(params) {
+        const layerId = params['layerId'];
+        const shapeId = params['shapeId'];
+
+        const shape = mapState.getCollisionShape(layerId, shapeId);
+        if (!shape) {
+          throw new Error(`Collision shape "${shapeId}" not found on layer "${layerId}"`);
+        }
+        // Deep-copy points array so snapshot survives removal.
+        const snapshot: RemoveCollisionSnapshot = {
+          shape: { ...shape, points: shape.points.map((p) => ({ ...p })) },
+        };
+
+        mapState.removeCollisionShape(layerId, shapeId);
+        return snapshot;
+      },
+      undo(params, _ctx, snapshot) {
+        const layerId = params['layerId'];
+        const typed = snapshot as RemoveCollisionSnapshot | undefined;
+        if (typed) {
+          // Restore the shape with its original ID intact.
+          mapState.restoreCollisionShape(layerId, typed.shape);
+        }
+      },
+      describe() {
+        return 'Removed collision shape';
+      },
+    });
+  },
+};

package/src/lib/leveleditor/level-editor-viewport-plugin.ts

@@ -0,0 +1,25 @@
+/**
+ * Level Editor Viewport plugin -- registers the tilemap editor panel with
+ * the central panel registry. Bootstrap auto-discovers this module via the
+ * `*-plugin.ts` glob in bootstrap.ts, so there's nothing else to wire up.
+ */
+
+import type { PluginModule } from '../core/plugin-loader.js';
+import LevelEditorViewport from './LevelEditorViewport.svelte';
+
+export const levelEditorViewportPlugin: PluginModule = {
+  name: 'leveleditor/viewport',
+  version: '1.0.0',
+  dependencies: [],
+  register(api) {
+    api.addPanel('level-editor', {
+      title: 'Level Editor',
+      component: LevelEditorViewport,
+      // Tabbed alongside the canvas in the center area. Users can drag it
+      // out to a side/bottom if they prefer a split view.
+      position: 'center',
+      minWidth: 200,
+      minHeight: 200,
+    });
+  },
+};

package/src/lib/leveleditor/map-properties-panel-plugin.ts

@@ -0,0 +1,25 @@
+/**
+ * Map Properties Panel Plugin -- registers MapPropertiesPanel as a dockable
+ * panel in the right sidebar. Allows editing grid dimensions, tile size,
+ * and grid projection mode for the level editor.
+ *
+ * Discovered by bootstrap via the `*-plugin.ts` glob.
+ */
+
+import type { PluginModule } from '../core/plugin-loader.js';
+import MapPropertiesPanel from './MapPropertiesPanel.svelte';
+
+export const mapPropertiesPanelPlugin: PluginModule = {
+  name: 'leveleditor/map-properties-panel',
+  version: '1.0.0',
+  dependencies: [],
+  register(api) {
+    api.addPanel('map-properties', {
+      title: 'Map Properties',
+      component: MapPropertiesPanel,
+      position: 'right',
+      minWidth: 160,
+      maxWidth: 300,
+    });
+  },
+};