Fix Asteroids collisions and load Object Vector Studio defaults from schema - PR_26133_033-asteroids-collision-and-object-vector-schema-defaults

Author: DavidQ

docs/dev/reports/asteroids_collision_and_object_vector_defaults_report.md

@@ -0,0 +1,42 @@
+# PR_26133_033 Asteroids Collision And Object Vector Defaults Report
+
+Date: 2026-05-14
+
+## Scope
+
+This change restores Asteroids collision behavior and moves Object Vector Studio V2 object/shape creation defaults into schema definitions while keeping object ids as the runtime SSoT.
+
+## Collision Fixes
+
+- Updated Asteroids asteroid collision-profile extraction to read point geometry from shape `tool: "polygon"`, matching the reduced Object Vector schema contract.
+- Confirmed Asteroids small, medium, and large asteroid profiles load polygon collision points from `games/Asteroids/game.manifest.json -> game.workspace.tools["object-vector-studio-v2"].objects[*].shapes[*].geometry`.
+- Added ship bullet vs UFO bullet crossfire collision resolution.
+- Preserved existing ship/asteroid, bullet/asteroid, UFO/asteroid, UFO bullet/asteroid, and ship/UFO crash collision flows.
+- No vector-map-editor fallback geometry was added or restored.
+
+## Schema Defaults
+
+- Added defaults to `tools/schemas/game.manifest.schema.json` for Object Vector Studio V2 object, shape common fields, style, transform, point2d, and all supported geometry definitions.
+- Mirrored the same defaults in `tools/schemas/tools/object-vector-studio-v2.schema.json` for standalone Object Vector Studio V2 validation/loading.
+- Added whole-object defaults for polygon and triangle geometry; polygon defaults use five points, and triangle defaults use exactly three points.
+
+## Tool Default Loading
+
+- Added `ObjectVectorStudioV2SchemaService.getDefinitionDefault()` so Object Vector Studio V2 clones defaults from the loaded schema.
+- New object creation now starts from the schema object default and applies the user-entered id/name/tags.
+- New shape creation now reads shape common, style, transform, and geometry defaults from schema definitions.
+- Missing schema defaults now produce visible blocked create/add failures instead of silent hardcoded fallback creation.
+- Shape transform origin remains derived from the created geometry bounds so current editing behavior stays centered; the transform base values come from the schema default.
+
+## Workspace Launch
+
+- Workspace Manager V2 generated Asteroids Object Vector payloads were verified with no `assetLibrary` field.
+- Generated `objects[*].tags` were verified present, including `object.asteroids.asteroid.small` tags `["asteroid", "small"]` loaded from the Asteroids manifest.
+
+## Validation
+
+- PASS - `npm run test:workspace-v2` -> 49 passed.
+- PASS - targeted Asteroids collision timing/stress checks for collision profiles and requested collision pairs.
+- PASS - targeted Asteroids validation smoke.
+- PASS - Node schema validation for `games/Asteroids/game.manifest.json` and generated workspace manifest.
+- PASS - search check found no Asteroids vector-map fallback geometry or `assetLibrary` payload usage outside schema rejection guards.

docs/dev/reports/playwright_v8_coverage_report.md

@@ -1,6 +1,6 @@
-# PR_26133_032 Playwright V8 Coverage Report
+# PR_26133_033 Playwright V8 Coverage Report
 
-Task: PR_26133_032-object-vector-schema-geometry-and-style-ssot
+Task: PR_26133_033-asteroids-collision-and-object-vector-schema-defaults
 Date: 2026-05-14
 
 ## Result
@@ -27,8 +27,8 @@ PASS - Coverage reporting was generated during `npm run test:workspace-v2`.
 
 ```text
 (83%) tools/object-vector-studio-v2/js/bootstrap.js - executed lines 109/109; executed functions 5/6
-(93%) tools/object-vector-studio-v2/js/ToolStarterApp.js - executed lines 4345/4345; executed functions 451/483
-(95%) tools/object-vector-studio-v2/js/services/ObjectVectorStudioV2SchemaService.js - executed lines 417/417; executed functions 53/56
+(93%) tools/object-vector-studio-v2/js/ToolStarterApp.js - executed lines 4333/4333; executed functions 453/485
+(95%) tools/object-vector-studio-v2/js/services/ObjectVectorStudioV2SchemaService.js - executed lines 453/453; executed functions 55/58
 (98%) src/engine/rendering/ObjectVectorRuntimeAssetService.js - executed lines 915/915; executed functions 107/109
 ```
 
@@ -40,4 +40,4 @@ PASS - Coverage reporting was generated during `npm run test:workspace-v2`.
 
 ## PR-Specific Note
 
-The Workspace V2 run exercised the Object Vector Studio V2 editor, schema service, runtime object-vector asset service, Asteroids runtime object-vector loading, and browser UI paths for fill/stroke opacity plus point2d geometry. Coverage remains advisory only.
+The Workspace V2 run exercised Object Vector Studio V2 launch, schema loading, schema-driven shape creation, generated Asteroids object-vector payload validation, and Asteroids runtime object-vector loading. Coverage remains advisory only.

docs/dev/reports/playwright_workspace_v2_results.md

@@ -1,6 +1,6 @@
-# PR_26133_032 Workspace V2 Playwright Results
+# PR_26133_033 Workspace V2 Playwright Results
 
-Task: PR_26133_032-object-vector-schema-geometry-and-style-ssot
+Task: PR_26133_033-asteroids-collision-and-object-vector-schema-defaults
 Date: 2026-05-14
 
 ## Result
@@ -10,21 +10,20 @@ PASS - `npm run test:workspace-v2` completed successfully.
 - Command: `npm run test:workspace-v2`
 - Playwright target: `tests/playwright/tools/WorkspaceManagerV2.spec.mjs --project=playwright --workers=1 --reporter=list`
 - Final result: 49 passed, 0 failed.
-- Focused rerun before the full suite: 1 passed for the Object Vector Studio V2 schema-only palette gate after opacity-control test updates.
+- Runtime/console guard: Workspace V2 tests that monitor page errors completed with no reported page errors.
 
 ## PR-Specific Coverage
 
-- Fill and stroke opacity controls apply to selected Object Vector shapes and persist as `fillOpacity` / `strokeOpacity`.
-- Object Vector Studio V2 loads Asteroids object tags from `objects[*].tags` with no `assetLibrary` payload.
-- Polygon editing enforces the new minimum of 4 points; default created polygons use 5 points.
-- Triangle shapes use fixed 3-point triangle geometry and keep Add/Delete Point hidden.
-- Line geometry loads/edits through `point1` / `point2`.
-- Transform origin loads/edits through `origin: { x, y }`.
-- Runtime object-vector rendering uses object ids as SSoT and validates the reduced Object Vector payload.
-- Runtime console checks: covered Workspace V2 flows asserted no page errors or console errors where the suite monitors them.
+- Object Vector Studio V2 schema defaults are present in the game manifest schema and the standalone tool schema.
+- New rectangle creation was verified against schema-cloned geometry/style/transform defaults.
+- Workspace Manager V2 generated the Asteroids Object Vector payload without `assetLibrary` and with `objects[*].tags` present.
+- Launching Object Vector Studio V2 for Asteroids from Workspace Manager V2 loaded 6 objects and validated the payload.
+- Dirty-state and save validation still pass after the generated manifest cleanup.
 
 ## Additional Validation
 
-PASS - Custom manifest/schema validation loaded `games/Asteroids/game.manifest.json`, validated the embedded Object Vector Studio V2 payload, and loaded it through `ObjectVectorRuntimeAssetService`.
+PASS - Targeted Asteroids collision checks covered ship/asteroid, bullet/asteroid, UFO/asteroid, UFO bullet/asteroid, ship bullet/UFO bullet crossfire, and ship/UFO crash cases.
 
-PASS - `node --check` for changed Object Vector JS and the Workspace Manager V2 Playwright spec.
+PASS - Targeted Asteroids validation smoke completed.
+
+PASS - Node schema validation reported `games/Asteroids/game.manifest.json` and the generated workspace manifest as schema-valid.

games/Asteroids/game/AsteroidsWorld.js

@@ -603,6 +603,32 @@ export default class AsteroidsWorld {
     this.status = 'Ship destroyed.';
   }
 
+  resolveBulletCrossfire(events) {
+    for (let bulletIndex = this.bullets.length - 1; bulletIndex >= 0; bulletIndex -= 1) {
+      const bullet = this.bullets[bulletIndex];
+      const bulletPolygon = bullet.getCollisionPolygon();
+
+      for (let ufoBulletIndex = this.ufoBullets.length - 1; ufoBulletIndex >= 0; ufoBulletIndex -= 1) {
+        const ufoBullet = this.ufoBullets[ufoBulletIndex];
+        if (!arePolygonsColliding(bulletPolygon, ufoBullet.getCollisionPolygon())) {
+          continue;
+        }
+
+        this.bullets.splice(bulletIndex, 1);
+        this.ufoBullets.splice(ufoBulletIndex, 1);
+        events.explosions.push({
+          x: (bullet.x + ufoBullet.x) / 2,
+          y: (bullet.y + ufoBullet.y) / 2,
+          size: 1,
+          source: 'bullet-crossfire',
+        });
+        events.sfx.push('bangSmall');
+        this.status = 'Opposing shots collided.';
+        break;
+      }
+    }
+  }
+
   updateStep(dtSeconds, input) {
     const events = createWorldEvents();
 
@@ -663,6 +689,7 @@ export default class AsteroidsWorld {
 
     this.ufoBullets.forEach((bullet) => bullet.update(safeDtSeconds, this.bounds));
     this.ufoBullets = this.ufoBullets.filter((bullet) => bullet.isAlive());
+    this.resolveBulletCrossfire(events);
 
     if (this.ufo) {
       const ufoPolygon = this.ufo.getCollisionPolygon();

games/Asteroids/game/asteroidObjectGeometry.js

@@ -60,7 +60,7 @@ function sortedShapes(object) {
 function extractPrimaryPolygonPoints(object) {
   const shape = sortedShapes(object).find((candidate) => (
     candidate?.visible !== false
-    && candidate?.type === 'polygon'
+    && candidate?.tool === 'polygon'
     && asArray(candidate?.geometry?.points).length >= 3
   ));
   return asArray(shape?.geometry?.points).map(cleanPoint);

tests/games/AsteroidsCollisionTimingStress.test.mjs

@@ -61,6 +61,10 @@ function assertClose(actual, expected, message) {
 
 export function run() {
   const asteroidGeometryProfiles = createAsteroidsTestGeometryProfiles();
+  Object.entries(asteroidGeometryProfiles).forEach(([size, profile]) => {
+    assert.equal(profile.points.length >= 4, true, `Asteroid size ${size} should load polygon collision points from object-vector-studio-v2 tool geometry.`);
+  });
+
   const collisionWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
   collisionWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
   collisionWorld.asteroids = [createStationaryAsteroid(collisionWorld, { x: 480, y: 400, size: 3 })];
@@ -75,6 +79,89 @@ export function run() {
   assert.equal(collisionWorld.bullets.length, 0);
   assert.equal(collisionWorld.asteroids.length, 2);
 
+  const shipImpactWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
+  shipImpactWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
+  shipImpactWorld.ship.invulnerable = 0;
+  shipImpactWorld.asteroids = [createStationaryAsteroid(shipImpactWorld, {
+    x: shipImpactWorld.ship.x,
+    y: shipImpactWorld.ship.y,
+    size: 3,
+  })];
+  const shipImpactEvents = shipImpactWorld.update(0, createInput());
+  assert.equal(shipImpactEvents.shipDestroyed, true);
+  assert.equal(shipImpactWorld.shipActive, false);
+
+  const ufoImpactWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
+  ufoImpactWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
+  ufoImpactWorld.asteroids = [createStationaryAsteroid(ufoImpactWorld, { x: 480, y: 360, size: 3 })];
+  ufoImpactWorld.ufo = ufoImpactWorld.createUfoEntity('large', 1);
+  ufoImpactWorld.ufo.x = 480;
+  ufoImpactWorld.ufo.y = 360;
+  ufoImpactWorld.ufo.vx = 0;
+  ufoImpactWorld.ufo.vy = 0;
+  ufoImpactWorld.ufo.turnTimer = Number.POSITIVE_INFINITY;
+  ufoImpactWorld.ufo.fireTimer = Number.POSITIVE_INFINITY;
+  const ufoImpactEvents = ufoImpactWorld.update(0, createInput());
+  assert.equal(ufoImpactWorld.ufo, null);
+  assert.equal(ufoImpactEvents.explosions.some((explosion) => explosion.source === 'ufo'), true);
+
+  const ufoBulletImpactWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
+  ufoBulletImpactWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
+  ufoBulletImpactWorld.asteroids = [createStationaryAsteroid(ufoBulletImpactWorld, { x: 480, y: 360, size: 3 })];
+  ufoBulletImpactWorld.ufo = ufoBulletImpactWorld.createUfoEntity('large', 1);
+  ufoBulletImpactWorld.ufo.x = 80;
+  ufoBulletImpactWorld.ufo.y = 80;
+  ufoBulletImpactWorld.ufo.vx = 0;
+  ufoBulletImpactWorld.ufo.vy = 0;
+  ufoBulletImpactWorld.ufo.turnTimer = Number.POSITIVE_INFINITY;
+  ufoBulletImpactWorld.ufo.fireTimer = Number.POSITIVE_INFINITY;
+  ufoBulletImpactWorld.ufoBullets = [ufoBulletImpactWorld.createBulletFromState(createBulletState({
+    x: 480,
+    y: 360,
+    vx: 0,
+    vy: 0,
+  }))];
+  const ufoBulletImpactEvents = ufoBulletImpactWorld.update(0, createInput());
+  assert.equal(ufoBulletImpactWorld.ufoBullets.length, 0);
+  assert.equal(ufoBulletImpactWorld.asteroids.length, 2);
+  assert.equal(ufoBulletImpactEvents.explosions.length > 0, true);
+
+  const bulletCrossfireWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
+  bulletCrossfireWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
+  bulletCrossfireWorld.asteroids = [];
+  bulletCrossfireWorld.ufo = null;
+  bulletCrossfireWorld.bullets = [bulletCrossfireWorld.createBulletFromState(createBulletState({
+    x: 480,
+    y: 360,
+    vx: 0,
+    vy: 0,
+  }))];
+  bulletCrossfireWorld.ufoBullets = [bulletCrossfireWorld.createBulletFromState(createBulletState({
+    x: 480,
+    y: 360,
+    vx: 0,
+    vy: 0,
+  }))];
+  const bulletCrossfireEvents = bulletCrossfireWorld.update(0, createInput());
+  assert.equal(bulletCrossfireWorld.bullets.length, 0);
+  assert.equal(bulletCrossfireWorld.ufoBullets.length, 0);
+  assert.equal(bulletCrossfireEvents.explosions.some((explosion) => explosion.source === 'bullet-crossfire'), true);
+
+  const shipUfoCrashWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.5, asteroidGeometryProfiles });
+  shipUfoCrashWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
+  shipUfoCrashWorld.asteroids = [];
+  shipUfoCrashWorld.ship.invulnerable = 0;
+  shipUfoCrashWorld.ufo = shipUfoCrashWorld.createUfoEntity('large', 1);
+  shipUfoCrashWorld.ufo.x = shipUfoCrashWorld.ship.x;
+  shipUfoCrashWorld.ufo.y = shipUfoCrashWorld.ship.y;
+  shipUfoCrashWorld.ufo.vx = 0;
+  shipUfoCrashWorld.ufo.vy = 0;
+  shipUfoCrashWorld.ufo.turnTimer = Number.POSITIVE_INFINITY;
+  shipUfoCrashWorld.ufo.fireTimer = Number.POSITIVE_INFINITY;
+  const shipUfoCrashEvents = shipUfoCrashWorld.update(0, createInput());
+  assert.equal(shipUfoCrashEvents.shipDestroyed, true);
+  assert.equal(shipUfoCrashWorld.ufo, null);
+
   const waveWorld = new AsteroidsWorld({ width: 960, height: 720 }, { rng: () => 0.25, asteroidGeometryProfiles });
   waveWorld.ufoSpawnTimer = Number.POSITIVE_INFINITY;
   waveWorld.asteroids = [createStationaryAsteroid(waveWorld, { x: 480, y: 400, size: 1 })];

tests/playwright/tools/WorkspaceManagerV2.spec.mjs

@@ -1211,6 +1211,30 @@ test.describe("Workspace Manager V2 bootstrap", () => {
       await expect(page.locator("body.tools-platform-tool-page[data-tool-id='object-vector-studio-v2']")).toBeVisible();
       await expect(page.locator("[data-tool-starter-header]")).toContainText("Object Vector Studio V2");
       await expect(page.locator("#statusLog")).toHaveValue(/OK Object Vector Studio V2 schema contract loaded from \/tools\/schemas\/tools\/object-vector-studio-v2\.schema\.json\./);
+      const objectVectorSchemaDefaults = await page.evaluate(async () => {
+        const toolSchema = window.__objectVectorStudioV2App.schemaService.schema;
+        const gameSchema = await fetch("/tools/schemas/game.manifest.schema.json", { cache: "no-store" }).then((response) => response.json());
+        return {
+          gameObjectDefaultTags: gameSchema.$defs.objectVectorStudioObject.default.tags,
+          gamePolygonDefaultPointCount: gameSchema.$defs.objectVectorStudioPolygonGeometry.default.points.length,
+          gameShapeCommonDefaultTool: gameSchema.$defs.objectVectorStudioShapeCommon.default.tool,
+          gameTransformDefaultOrigin: gameSchema.$defs.objectVectorStudioTransform.default.origin,
+          toolPolygonDefaultPointCount: toolSchema.$defs.polygonGeometry.default.points.length,
+          toolShapeCommonDefaultTool: toolSchema.$defs.shapeCommon.default.tool,
+          toolStyleDefaultStrokeWidth: toolSchema.$defs.style.default.strokeWidth,
+          toolTransformDefaultOrigin: toolSchema.$defs.transform.default.origin
+        };
+      });
+      expect(objectVectorSchemaDefaults).toEqual({
+        gameObjectDefaultTags: [],
+        gamePolygonDefaultPointCount: 5,
+        gameShapeCommonDefaultTool: "polygon",
+        gameTransformDefaultOrigin: { x: 0, y: 0 },
+        toolPolygonDefaultPointCount: 5,
+        toolShapeCommonDefaultTool: "polygon",
+        toolStyleDefaultStrokeWidth: 3,
+        toolTransformDefaultOrigin: { x: 0, y: 0 }
+      });
       await expect(page.locator('[data-launch-mode-nav="tool"]')).toBeVisible();
       await expect(page.locator('[data-launch-mode-nav="tool"] button')).toHaveText(["Import", "Copy JSON", "Export", "Export SVG"]);
       await expect(page.locator('[data-launch-mode-nav="workspace"]')).toBeHidden();
@@ -1869,6 +1893,44 @@ test.describe("Workspace Manager V2 bootstrap", () => {
       await expect(page.locator("#objectVectorStudioV2DeleteShapeButton")).toHaveCount(0);
       await expect(page.locator("#statusLog")).toHaveValue(/OK Created rectangle shape on Asteroids Ship\./);
       await expect(page.locator("#statusLog")).toHaveValue(/OK Render mode svg-work-surface: rendered Asteroids Ship with 1 visible shapes; capture mode none\./);
+      const createdRectangleSchemaDefaults = await page.evaluate(() => {
+        const app = window.__objectVectorStudioV2App;
+        const schema = app.schemaService.schema;
+        const shape = app.selectedShape();
+        return {
+          geometry: shape.geometry,
+          locked: shape.locked,
+          schemaGeometry: schema.$defs.rectangleGeometry.default,
+          schemaShapeCommon: schema.$defs.shapeCommon.default,
+          schemaStyle: schema.$defs.style.default,
+          schemaTransform: schema.$defs.transform.default,
+          style: shape.style,
+          tool: shape.tool,
+          transform: shape.transform,
+          visible: shape.visible
+        };
+      });
+      expect(createdRectangleSchemaDefaults).toMatchObject({
+        geometry: createdRectangleSchemaDefaults.schemaGeometry,
+        locked: createdRectangleSchemaDefaults.schemaShapeCommon.locked,
+        style: {
+          fill: "#ffffff",
+          fillOpacity: createdRectangleSchemaDefaults.schemaStyle.fillOpacity,
+          stroke: "#ffffff",
+          strokeOpacity: createdRectangleSchemaDefaults.schemaStyle.strokeOpacity,
+          strokeWidth: createdRectangleSchemaDefaults.schemaStyle.strokeWidth
+        },
+        tool: "rectangle",
+        transform: {
+          origin: { x: -40, y: 0 },
+          rotation: createdRectangleSchemaDefaults.schemaTransform.rotation,
+          scaleX: createdRectangleSchemaDefaults.schemaTransform.scaleX,
+          scaleY: createdRectangleSchemaDefaults.schemaTransform.scaleY,
+          x: createdRectangleSchemaDefaults.schemaTransform.x,
+          y: createdRectangleSchemaDefaults.schemaTransform.y
+        },
+        visible: createdRectangleSchemaDefaults.schemaShapeCommon.visible
+      });
 
       await page.locator('[data-shape-tool="circle"]').click();
       await expect(page.locator("#objectVectorStudioV2ObjectsCount")).toHaveText("(18 obj, 2 shapes)");
@@ -7278,6 +7340,10 @@ test.describe("Workspace Manager V2 bootstrap", () => {
       await page.locator("#activeGameSelect").selectOption("Asteroids");
       await expectWorkspaceReturnRehydrated(page);
       await expect(page.locator("#saveWorkspaceButton")).toBeDisabled();
+      const generatedObjectVectorPayload = JSON.parse(await page.locator("#workspaceContextOutput").inputValue()).tools["object-vector-studio-v2"];
+      expect(generatedObjectVectorPayload.assetLibrary).toBeUndefined();
+      expect(generatedObjectVectorPayload.objects.every((object) => Array.isArray(object.tags))).toBe(true);
+      expect(generatedObjectVectorPayload.objects.find((object) => object.id === "object.asteroids.asteroid.small").tags).toEqual(["asteroid", "small"]);
 
       await page.locator('[data-workspace-tool-id="object-vector-studio-v2"]').click();
       await expect(page).toHaveURL(/object-vector-studio-v2\/index\.html.*launch=workspace/);