A tile gains Collision scale: below 1 each blocking cell pulls in on the sides without a blocking neighbour and stays flush towards its neighbours, so a wall of bushes becomes a narrower wall without gaps and the inner corner of an L closes cleanly; above 1 the cell grows at its open sides; on several layers the largest value counts, and the merged rectangles work in fractions of a cell with exactly the old result at 1 (#140)

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/model/tile.ts

@@ -20,6 +20,10 @@ export const TILE_FPS_KEY = 'fps';
 export const TILE_PLAYBACK_KEY = 'playback';
 /** Whether a cell of this tile blocks movement in the running game (#132). */
 export const TILE_SOLID_KEY = 'solid';
+/** How big the blocking box of a cell is against the cell, 1 = the whole cell (#140). */
+export const TILE_COLLISION_SCALE_KEY = 'collisionScale';
+export const TILE_COLLISION_SCALE_MIN = 0.1;
+export const TILE_COLLISION_SCALE_MAX = 2;
 
 /** Only the two that make sense for a tile that is always on screen; there is no end to hold. */
 export const TILE_PLAYBACKS = ['loop', 'pingpong'] as const;
@@ -45,6 +49,13 @@ export function isTileSolid(asset: TileAsset): boolean {
   return asset.props[TILE_SOLID_KEY] === true;
 }
 
+/** The collision scale, held to the range the field offers; anything unreadable is the whole cell. */
+export function tileCollisionScale(asset: TileAsset): number {
+  const scale = Number(asset.props[TILE_COLLISION_SCALE_KEY] ?? 1);
+  if (!Number.isFinite(scale)) return 1;
+  return Math.min(TILE_COLLISION_SCALE_MAX, Math.max(TILE_COLLISION_SCALE_MIN, scale));
+}
+
 export function tileFps(asset: TileAsset): number {
   const fps = Number(asset.props[TILE_FPS_KEY]);
   return Number.isFinite(fps) && fps > 0 ? fps : 0;

src/core/model/tilemapCollision.ts

@@ -6,16 +6,21 @@
  * The blocking cells are merged into rectangles rather than handed on one box each, so a wall is
  * one shape and the collision tests stay few – and so an object sliding along a wall does not
  * catch on the seam between two of its cells.
+ *
+ * A tile's collision scale (#140) draws the box in or out, but only on the sides *without* a
+ * blocking neighbour: between two blocking cells the side stays flush whatever their values, so a
+ * wall of bushes is a narrower wall and not a string of beads. A neighbour across the corner only
+ * does not count – that corner stays drawn in.
  */
 import type { TilemapAsset } from './Asset';
 import { angleOf, apply, type Mat, scaleOf } from './matrix';
 import type { PropertyBag } from './Properties';
 import { findAssetOf, type Project } from './Project';
-import { isTileSolid } from './tile';
+import { isTileSolid, tileCollisionScale } from './tile';
 import { cellOrigin, inGrid, parseCellKey, tilemapTileSize } from './tilemap';
 import type { ColliderShape } from '../properties/collider';
 
-/** A rectangle of cells: top-left cell and size, all in cells. */
+/** A rectangle in cells: top-left corner and size. Whole cells at collision scale 1, parts of one otherwise. */
 export interface CellRect {
   x: number;
   y: number;
@@ -23,84 +28,142 @@ export interface CellRect {
   h: number;
 }
 
-/** Every blocking cell of the map, once each however many layers hold a solid tile there. */
-export function solidCells(
-  project: Project,
-  props: PropertyBag,
-  asset: TilemapAsset,
-): { x: number; y: number }[] {
-  const solid = new Map<string, boolean>();
-  const isSolid = (id: string): boolean => {
-    const known = solid.get(id);
-    if (known !== undefined) return known;
-    const tile = findAssetOf(project, id, 'tile');
-    const value = Boolean(tile && isTileSolid(tile));
-    solid.set(id, value);
-    return value;
-  };
-  const seen = new Set<string>();
-  const cells: { x: number; y: number }[] = [];
-  for (const layer of asset.layers) {
-    for (const [key, tileId] of Object.entries(layer.cells)) {
-      if (!tileId || seen.has(key) || !isSolid(tileId)) continue;
-      const at = parseCellKey(key);
-      if (!at || !inGrid(props, at.x, at.y)) continue;
-      seen.add(key);
-      cells.push(at);
-    }
-  }
-  return cells;
+/** A blocking cell and the collision scale of its tile; left out, the scale is 1. */
+export interface SolidCell {
+  x: number;
+  y: number;
+  scale?: number;
 }
 
 /**
- * The cells merged into rectangles, row by row: each row is cut into runs, and a run that spans
- * exactly the columns of a rectangle ending right above it makes that rectangle one row taller.
- * Every cell lands in exactly one rectangle; the result is ordered top-down, then left to right.
+ * Every blocking cell of the map, once each however many layers hold a solid tile there. Where
+ * several do, the largest scale wins: each of them blocks, so the cell blocks as far as any does.
  */
-export function mergeCells(cells: readonly { x: number; y: number }[]): CellRect[] {
-  const rows = new Map<number, number[]>();
-  for (const { x, y } of cells) {
-    const row = rows.get(y);
-    if (row) row.push(x);
-    else rows.set(y, [x]);
-  }
-  const done: CellRect[] = [];
-  // Rectangles still open at the bottom, by the columns they span.
-  let open = new Map<string, CellRect>();
-  let previous = Number.NaN;
-  for (const y of [...rows.keys()].sort((a, b) => a - b)) {
-    if (y !== previous + 1) {
-      done.push(...open.values());
-      open = new Map();
+export function solidCells(project: Project, props: PropertyBag, asset: TilemapAsset): Required<SolidCell>[] {
+  const scales = new Map<string, number | null>();
+  const scaleOf = (id: string): number | null => {
+    const known = scales.get(id);
+    if (known !== undefined) return known;
+    const tile = findAssetOf(project, id, 'tile');
+    const value = tile && isTileSolid(tile) ? tileCollisionScale(tile) : null;
+    scales.set(id, value);
+    return value;
+  };
+  const found = new Map<string, Required<SolidCell>>();
+  for (const layer of asset.layers) {
+    for (const [key, tileId] of Object.entries(layer.cells)) {
+      const scale = tileId ? scaleOf(tileId) : null;
+      if (scale === null) continue;
+      const known = found.get(key);
+      if (known) {
+        known.scale = Math.max(known.scale, scale);
+        continue;
+      }
+      const at = parseCellKey(key);
+      if (!at || !inGrid(props, at.x, at.y)) continue;
+      found.set(key, { ...at, scale });
     }
-    const next = new Map<string, CellRect>();
-    for (const [x0, w] of runsOf(rows.get(y)!)) {
-      const key = `${x0},${w}`;
-      const above = open.get(key);
-      if (above) {
-        above.h++;
-        open.delete(key);
-        next.set(key, above);
-      } else next.set(key, { x: x0, y, w, h: 1 });
-    }
-    done.push(...open.values());
-    open = next;
-    previous = y;
   }
-  done.push(...open.values());
-  return done.sort((a, b) => a.y - b.y || a.x - b.x);
+  return [...found.values()];
 }
 
-/** Runs of neighbouring columns as `[first column, length]`; doubles count once. */
-function runsOf(columns: number[]): [number, number][] {
-  const sorted = [...new Set(columns)].sort((a, b) => a - b);
-  const runs: [number, number][] = [];
-  for (const x of sorted) {
-    const last = runs[runs.length - 1];
-    if (last && last[0] + last[1] === x) last[1]++;
-    else runs.push([x, 1]);
+/** A rectangle by its four sides, which is what the merge compares. */
+interface Piece {
+  x0: number;
+  x1: number;
+  y0: number;
+  y1: number;
+}
+
+/**
+ * The part of the map one cell blocks, as pieces. At scale 1 that is the cell. Below 1 the cell is
+ * cut at the inset `e` into a 3 × 3 grid: the middle always blocks, a side strip only towards a
+ * blocking neighbour, a corner only when both its sides *and* the cell across the corner block –
+ * which is what closes the inner corner of an L cleanly instead of leaving a notch filled. Above 1
+ * the cell grows by the same amount on every side without a blocking neighbour.
+ */
+function cellPieces(cell: SolidCell, blocks: (x: number, y: number) => boolean): Piece[] {
+  const { x, y } = cell;
+  const e = (1 - (cell.scale ?? 1)) / 2;
+  const left = blocks(x - 1, y);
+  const right = blocks(x + 1, y);
+  const up = blocks(x, y - 1);
+  const down = blocks(x, y + 1);
+  if (e <= 0) {
+    const g = -e;
+    return [
+      {
+        x0: x - (left ? 0 : g),
+        x1: x + 1 + (right ? 0 : g),
+        y0: y - (up ? 0 : g),
+        y1: y + 1 + (down ? 0 : g),
+      },
+    ];
   }
-  return runs;
+  // Bands along each axis: [start, end, neighbour side (-1, 0, 1)]; the same expressions on both
+  // sides of a cut keep touching pieces exactly equal, so they merge.
+  const bands = (at: number): [number, number, -1 | 0 | 1][] => [
+    [at, at + e, -1],
+    [at + e, at + (1 - e), 0],
+    [at + (1 - e), at + 1, 1],
+  ];
+  const pieces: Piece[] = [];
+  for (const [y0, y1, dy] of bands(y)) {
+    for (const [x0, x1, dx] of bands(x)) {
+      const side = (dx === 0 || (dx < 0 ? left : right)) && (dy === 0 || (dy < 0 ? up : down));
+      if (side && (dx === 0 || dy === 0 || blocks(x + dx, y + dy))) pieces.push({ x0, x1, y0, y1 });
+    }
+  }
+  return pieces;
+}
+
+/**
+ * The cells merged into rectangles. Each cell is cut into its pieces (see `cellPieces`); pieces on
+ * the same strip – same top and bottom – that touch or overlap join into one, and then strips of
+ * exactly the same left and right that meet top to bottom join into one taller rectangle. At scale 1
+ * every piece is a cell, so a run joins across a row and runs of the same columns stack. The result
+ * is ordered top-down, then left to right.
+ */
+export function mergeCells(cells: readonly SolidCell[]): CellRect[] {
+  const unique = new Map<string, SolidCell>();
+  for (const cell of cells) unique.set(`${cell.x},${cell.y}`, cell);
+  const blocks = (x: number, y: number) => unique.has(`${x},${y}`);
+  const strips = new Map<string, Piece[]>();
+  for (const cell of unique.values()) {
+    for (const piece of cellPieces(cell, blocks)) {
+      const key = `${piece.y0},${piece.y1}`;
+      const strip = strips.get(key);
+      if (strip) strip.push(piece);
+      else strips.set(key, [piece]);
+    }
+  }
+  const runs: Piece[] = [];
+  for (const strip of strips.values()) {
+    strip.sort((a, b) => a.x0 - b.x0);
+    let run: Piece | null = null;
+    for (const piece of strip) {
+      if (run && piece.x0 <= run.x1) run.x1 = Math.max(run.x1, piece.x1);
+      else runs.push((run = { ...piece }));
+    }
+  }
+  runs.sort((a, b) => a.y0 - b.y0 || a.x0 - b.x0);
+  const done: Piece[] = [];
+  // Rectangles still open at the bottom, by the left and right they span.
+  const open = new Map<string, Piece>();
+  for (const run of runs) {
+    const key = `${run.x0},${run.x1}`;
+    const above = open.get(key);
+    if (above && above.y1 === run.y0) {
+      above.y1 = run.y1;
+      continue;
+    }
+    if (above) done.push(above);
+    open.set(key, run);
+  }
+  done.push(...open.values());
+  return done
+    .sort((a, b) => a.y0 - b.y0 || a.x0 - b.x0)
+    .map((p) => ({ x: p.x0, y: p.y0, w: p.x1 - p.x0, h: p.y1 - p.y0 }));
 }
 
 /** The blocking rectangles of a map, in cells. */

src/core/properties/PropertySchema.ts

@@ -20,7 +20,15 @@ import {
   type VariableKind,
 } from './kinds';
 import { findAssetOf, type Project } from '../model/Project';
-import { TILE_FPS_KEY, TILE_KIND_KEY, TILE_PLAYBACK_KEY, TILE_SOLID_KEY } from '../model/tile';
+import {
+  TILE_COLLISION_SCALE_KEY,
+  TILE_COLLISION_SCALE_MAX,
+  TILE_COLLISION_SCALE_MIN,
+  TILE_FPS_KEY,
+  TILE_KIND_KEY,
+  TILE_PLAYBACK_KEY,
+  TILE_SOLID_KEY,
+} from '../model/tile';
 import { TILEMAP_COLUMNS_KEY, TILEMAP_MAX_CELLS, TILEMAP_ROWS_KEY, TILEMAP_TILE_KEY } from '../model/tilemap';
 import { SLICE_SCALE_KEY } from '../model/texture';
 import type { SceneObject } from '../model/SceneObject';
@@ -249,6 +257,17 @@ const ASSET_SCHEMAS: Record<AssetType, PropertySchema> = {
     },
     // Solid is what the tile *is* – water, a wall – so it holds wherever the tile lies (#132).
     { key: TILE_SOLID_KEY, label: 'Solid', kind: 'boolean', default: false },
+    // Below 1 a cell blocks less than its square, above 1 more – but only on the sides without a
+    // blocking neighbour, so a wall of such cells stays closed (#140).
+    {
+      key: TILE_COLLISION_SCALE_KEY,
+      label: 'Collision scale',
+      kind: 'number',
+      default: 1,
+      min: TILE_COLLISION_SCALE_MIN,
+      max: TILE_COLLISION_SCALE_MAX,
+      step: 0.05,
+    },
   ],
   // The layers and their cells are intrinsic data on the asset (see TilemapAsset); these three say
   // how far the grid reaches and how big one cell is drawn. A tile's own pictures are scaled onto