@auraindustry/aurajs 0.1.1 → 0.1.5

package/src/helpers/starter-utils/tilemap-nav-2d.js

@@ -0,0 +1,499 @@
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function positiveInteger(value, fallback = null) {
+  const numeric = Math.floor(finite(value, Number.NaN));
+  return numeric >= 1 ? numeric : fallback;
+}
+
+function normalizeCell(entry) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+  const x = Math.floor(finite(entry.x, Number.NaN));
+  const y = Math.floor(finite(entry.y, Number.NaN));
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  return { x, y };
+}
+
+function cellKey(x, y) {
+  return `${x}:${y}`;
+}
+
+function keyToCell(key) {
+  const [x, y] = String(key).split(':');
+  return {
+    x: Number.parseInt(x, 10),
+    y: Number.parseInt(y, 10),
+  };
+}
+
+function inBounds(nav, x, y) {
+  return x >= 0 && y >= 0 && x < nav.width && y < nav.height;
+}
+
+function trimCache(nav) {
+  while (nav.cache.size > nav.maxCacheEntries) {
+    const firstKey = nav.cache.keys().next().value;
+    if (firstKey == null) return;
+    nav.cache.delete(firstKey);
+  }
+}
+
+function createBlockedGrid(width, height) {
+  return new Uint8Array(width * height);
+}
+
+function applyBlockedCells(nav, entries = [], blocked = true) {
+  if (!(nav.blockedGrid instanceof Uint8Array)) return 0;
+  let changed = 0;
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const cell = normalizeCell(entry);
+    if (!cell || !inBounds(nav, cell.x, cell.y)) continue;
+    const index = (cell.y * nav.width) + cell.x;
+    const nextValue = blocked ? 1 : 0;
+    if (nav.blockedGrid[index] === nextValue) continue;
+    nav.blockedGrid[index] = nextValue;
+    changed += 1;
+  }
+  return changed;
+}
+
+function loadBlockedGrid(nav, options = {}) {
+  const width = nav.width;
+  const height = nav.height;
+  const cellCount = width * height;
+  const grid = createBlockedGrid(width, height);
+  const blockedGrid = Array.isArray(options.blockedGrid) || ArrayBuffer.isView(options.blockedGrid)
+    ? options.blockedGrid
+    : null;
+
+  if (blockedGrid && blockedGrid.length >= cellCount) {
+    for (let index = 0; index < cellCount; index += 1) {
+      grid[index] = blockedGrid[index] ? 1 : 0;
+    }
+  }
+
+  nav.blockedGrid = grid;
+  applyBlockedCells(nav, options.blockedCells, true);
+}
+
+function markNavDirty(nav, kind = 'topology') {
+  if (kind === 'occupancy') {
+    nav.occupancyVersion += 1;
+  } else {
+    nav.topologyVersion += 1;
+  }
+  nav.cache.clear();
+}
+
+function sameCell(a, b) {
+  return !!a && !!b && a.x === b.x && a.y === b.y;
+}
+
+function normalizeIgnoreCells(entries = []) {
+  const set = new Set();
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const cell = normalizeCell(entry);
+    if (!cell) continue;
+    set.add(cellKey(cell.x, cell.y));
+  }
+  return set;
+}
+
+function neighborDirections(allowDiagonal) {
+  if (allowDiagonal) {
+    return [
+      { x: 1, y: 0, cost: 1 },
+      { x: -1, y: 0, cost: 1 },
+      { x: 0, y: 1, cost: 1 },
+      { x: 0, y: -1, cost: 1 },
+      { x: 1, y: 1, cost: Math.SQRT2 },
+      { x: 1, y: -1, cost: Math.SQRT2 },
+      { x: -1, y: 1, cost: Math.SQRT2 },
+      { x: -1, y: -1, cost: Math.SQRT2 },
+    ];
+  }
+  return [
+    { x: 1, y: 0, cost: 1 },
+    { x: -1, y: 0, cost: 1 },
+    { x: 0, y: 1, cost: 1 },
+    { x: 0, y: -1, cost: 1 },
+  ];
+}
+
+function heuristicFor(allowDiagonal, fromX, fromY, toX, toY) {
+  const dx = Math.abs(toX - fromX);
+  const dy = Math.abs(toY - fromY);
+  return allowDiagonal ? Math.max(dx, dy) : (dx + dy);
+}
+
+function cellBlocked(nav, x, y) {
+  if (!inBounds(nav, x, y)) return true;
+  if (nav.blockedGrid instanceof Uint8Array && nav.blockedGrid[(y * nav.width) + x] === 1) {
+    return true;
+  }
+  if (typeof nav.isBlocked === 'function') {
+    return nav.isBlocked(x, y, nav) === true;
+  }
+  return false;
+}
+
+function buildCacheKey(nav, start, goal, options = {}) {
+  return [
+    `${start.x}:${start.y}`,
+    `${goal.x}:${goal.y}`,
+    options.allowDiagonal === true || (options.allowDiagonal == null && nav.allowDiagonal === true) ? 'diag' : 'cardinal',
+    `occupied:${Number.isFinite(options.occupiedCost) ? Number(options.occupiedCost) : nav.occupiedCost}`,
+    options.allowGoalOccupied === true ? 'goal-ok' : 'goal-solid',
+  ].join('|');
+}
+
+function cacheResult(nav, key, result) {
+  nav.cache.set(key, {
+    topologyVersion: nav.topologyVersion,
+    occupancyVersion: nav.occupancyVersion,
+    result,
+  });
+  trimCache(nav);
+}
+
+function cachedResult(nav, key) {
+  const entry = nav.cache.get(key);
+  if (!entry) return null;
+  if (
+    entry.topologyVersion !== nav.topologyVersion
+    || entry.occupancyVersion !== nav.occupancyVersion
+  ) {
+    nav.cache.delete(key);
+    return null;
+  }
+  return {
+    ...entry.result,
+    usedCache: true,
+  };
+}
+
+export function createTilemapNav2D(options = {}) {
+  const width = positiveInteger(options.width, 0) || 0;
+  const height = positiveInteger(options.height, 0) || 0;
+  const nav = {
+    width,
+    height,
+    allowDiagonal: options.allowDiagonal === true,
+    occupiedCost: Number.isFinite(options.occupiedCost) ? Number(options.occupiedCost) : 4,
+    maxCacheEntries: positiveInteger(options.maxCacheEntries, 96) || 96,
+    isBlocked: typeof options.isBlocked === 'function' ? options.isBlocked : null,
+    blockedGrid: null,
+    occupiedCells: new Set(),
+    topologyVersion: 1,
+    occupancyVersion: 1,
+    cache: new Map(),
+  };
+  loadBlockedGrid(nav, options);
+  return nav;
+}
+
+export function rebuildTilemapNav2D(nav, options = {}) {
+  if (!nav || typeof nav !== 'object') {
+    throw new Error('tilemap nav state is required.');
+  }
+  nav.width = positiveInteger(options.width ?? nav.width, nav.width) || 0;
+  nav.height = positiveInteger(options.height ?? nav.height, nav.height) || 0;
+  nav.allowDiagonal = options.allowDiagonal === true || (options.allowDiagonal == null && nav.allowDiagonal === true);
+  nav.occupiedCost = Number.isFinite(options.occupiedCost) ? Number(options.occupiedCost) : nav.occupiedCost;
+  nav.maxCacheEntries = positiveInteger(options.maxCacheEntries, nav.maxCacheEntries) || nav.maxCacheEntries;
+  nav.isBlocked = typeof options.isBlocked === 'function'
+    ? options.isBlocked
+    : (options.isBlocked === null ? null : nav.isBlocked);
+  loadBlockedGrid(nav, options);
+  nav.occupiedCells = new Set();
+  markNavDirty(nav, 'topology');
+  return nav;
+}
+
+export function invalidateTilemapNav2D(nav, options = {}) {
+  if (!nav || typeof nav !== 'object') {
+    return {
+      ok: false,
+      reasonCode: 'invalid_nav_state',
+      changedCells: 0,
+      topologyVersion: 0,
+    };
+  }
+
+  let changedCells = 0;
+  if (Array.isArray(options.cells)) {
+    changedCells += applyBlockedCells(
+      nav,
+      options.cells,
+      options.blocked !== false,
+    );
+  }
+
+  if (options.rect && typeof options.rect === 'object' && !Array.isArray(options.rect)) {
+    const x = Math.floor(finite(options.rect.x, Number.NaN));
+    const y = Math.floor(finite(options.rect.y, Number.NaN));
+    const w = positiveInteger(options.rect.w ?? options.rect.width, 0) || 0;
+    const h = positiveInteger(options.rect.h ?? options.rect.height, 0) || 0;
+    if (Number.isFinite(x) && Number.isFinite(y) && w > 0 && h > 0) {
+      const cells = [];
+      for (let row = y; row < y + h; row += 1) {
+        for (let col = x; col < x + w; col += 1) {
+          cells.push({ x: col, y: row });
+        }
+      }
+      changedCells += applyBlockedCells(nav, cells, options.blocked !== false);
+    }
+  }
+
+  markNavDirty(nav, 'topology');
+  return {
+    ok: true,
+    reasonCode: null,
+    changedCells,
+    topologyVersion: nav.topologyVersion,
+  };
+}
+
+export function collectTilemapOccupiedCells2D(entries = [], options = {}) {
+  const cells = [];
+  const seen = new Set();
+  const resolveCell = typeof options.resolveCell === 'function'
+    ? options.resolveCell
+    : (entry) => entry;
+  const width = positiveInteger(options.width, null);
+  const height = positiveInteger(options.height, null);
+
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const cell = normalizeCell(resolveCell(entry));
+    if (!cell) continue;
+    if (width != null && height != null && (cell.x < 0 || cell.y < 0 || cell.x >= width || cell.y >= height)) {
+      continue;
+    }
+    const key = cellKey(cell.x, cell.y);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    cells.push(cell);
+  }
+  return cells;
+}
+
+export function setTilemapNavOccupiedCells2D(nav, entries = [], options = {}) {
+  if (!nav || typeof nav !== 'object') {
+    return {
+      ok: false,
+      reasonCode: 'invalid_nav_state',
+      occupiedCount: 0,
+      occupancyVersion: 0,
+    };
+  }
+
+  const cells = collectTilemapOccupiedCells2D(entries, {
+    width: nav.width,
+    height: nav.height,
+    resolveCell: options.resolveCell,
+  });
+  const next = new Set(cells.map((cell) => cellKey(cell.x, cell.y)));
+  const currentKeys = [...nav.occupiedCells];
+  const changed = currentKeys.length !== next.size
+    || currentKeys.some((key) => !next.has(key));
+
+  if (changed) {
+    nav.occupiedCells = next;
+    markNavDirty(nav, 'occupancy');
+  }
+
+  return {
+    ok: true,
+    reasonCode: null,
+    changed,
+    occupiedCount: next.size,
+    occupancyVersion: nav.occupancyVersion,
+  };
+}
+
+export function findTilemapPath2D(nav, startCell, goalCell, options = {}) {
+  if (!nav || typeof nav !== 'object' || nav.width <= 0 || nav.height <= 0) {
+    return {
+      ok: false,
+      reasonCode: 'invalid_nav_state',
+      cells: [],
+      nextCell: null,
+      steps: 0,
+      usedCache: false,
+    };
+  }
+
+  const start = normalizeCell(startCell);
+  const goal = normalizeCell(goalCell);
+  if (!start || !inBounds(nav, start.x, start.y)) {
+    return {
+      ok: false,
+      reasonCode: 'invalid_start_cell',
+      cells: [],
+      nextCell: null,
+      steps: 0,
+      usedCache: false,
+    };
+  }
+  if (!goal || !inBounds(nav, goal.x, goal.y)) {
+    return {
+      ok: false,
+      reasonCode: 'invalid_goal_cell',
+      cells: [],
+      nextCell: null,
+      steps: 0,
+      usedCache: false,
+    };
+  }
+
+  const allowDiagonal = options.allowDiagonal === true || (options.allowDiagonal == null && nav.allowDiagonal === true);
+  const allowGoalOccupied = options.allowGoalOccupied === true;
+  const occupiedCost = Number.isFinite(options.occupiedCost) ? Number(options.occupiedCost) : nav.occupiedCost;
+  const ignoreCells = normalizeIgnoreCells(options.ignoreCells);
+
+  if (!sameCell(start, goal) && cellBlocked(nav, goal.x, goal.y) === true) {
+    return {
+      ok: false,
+      reasonCode: 'goal_blocked',
+      cells: [],
+      nextCell: null,
+      steps: 0,
+      usedCache: false,
+    };
+  }
+
+  const cacheKey = buildCacheKey(nav, start, goal, {
+    allowDiagonal,
+    allowGoalOccupied,
+    occupiedCost,
+  });
+  const cached = cachedResult(nav, cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  const startKey = cellKey(start.x, start.y);
+  const goalKey = cellKey(goal.x, goal.y);
+  const directions = neighborDirections(allowDiagonal);
+  const maxIterations = positiveInteger(options.maxIterations, Math.max(256, nav.width * nav.height * 4)) || 256;
+
+  const open = [startKey];
+  const openSet = new Set(open);
+  const cameFrom = new Map();
+  const gScore = new Map([[startKey, 0]]);
+  const fScore = new Map([[startKey, heuristicFor(allowDiagonal, start.x, start.y, goal.x, goal.y)]]);
+
+  let iterations = 0;
+  while (open.length > 0 && iterations < maxIterations) {
+    iterations += 1;
+    open.sort((left, right) => (fScore.get(left) ?? Infinity) - (fScore.get(right) ?? Infinity));
+    const currentKey = open.shift();
+    openSet.delete(currentKey);
+    if (currentKey === goalKey) {
+      const cells = [];
+      let key = currentKey;
+      while (key) {
+        cells.push(keyToCell(key));
+        key = cameFrom.get(key) || '';
+      }
+      cells.reverse();
+      const result = {
+        ok: true,
+        reasonCode: null,
+        cells,
+        nextCell: cells[1] || cells[0] || null,
+        steps: Math.max(0, cells.length - 1),
+        usedCache: false,
+        topologyVersion: nav.topologyVersion,
+        occupancyVersion: nav.occupancyVersion,
+      };
+      cacheResult(nav, cacheKey, result);
+      return result;
+    }
+
+    const current = keyToCell(currentKey);
+    for (const direction of directions) {
+      const nextX = current.x + direction.x;
+      const nextY = current.y + direction.y;
+      if (!inBounds(nav, nextX, nextY)) continue;
+
+      if (direction.x !== 0 && direction.y !== 0) {
+        if (cellBlocked(nav, current.x + direction.x, current.y) || cellBlocked(nav, current.x, current.y + direction.y)) {
+          continue;
+        }
+      }
+
+      const nextKey = cellKey(nextX, nextY);
+      if (nextKey !== goalKey && nextKey !== startKey && !ignoreCells.has(nextKey) && cellBlocked(nav, nextX, nextY)) {
+        continue;
+      }
+
+      const occupiedPenalty = nav.occupiedCells.has(nextKey)
+        && nextKey !== goalKey
+        && nextKey !== startKey
+        && !ignoreCells.has(nextKey)
+        ? occupiedCost
+        : 0;
+      if (!allowGoalOccupied && nextKey === goalKey && nav.occupiedCells.has(nextKey) && !ignoreCells.has(nextKey)) {
+        continue;
+      }
+
+      const tentativeG = (gScore.get(currentKey) ?? Infinity) + direction.cost + occupiedPenalty;
+      if (tentativeG >= (gScore.get(nextKey) ?? Infinity)) {
+        continue;
+      }
+
+      cameFrom.set(nextKey, currentKey);
+      gScore.set(nextKey, tentativeG);
+      fScore.set(
+        nextKey,
+        tentativeG + heuristicFor(allowDiagonal, nextX, nextY, goal.x, goal.y),
+      );
+
+      if (!openSet.has(nextKey)) {
+        open.push(nextKey);
+        openSet.add(nextKey);
+      }
+    }
+  }
+
+  return {
+    ok: false,
+    reasonCode: iterations >= maxIterations ? 'search_budget_exhausted' : 'path_not_found',
+    cells: [],
+    nextCell: null,
+    steps: 0,
+    usedCache: false,
+  };
+}
+
+export function resolveTilemapStep2D(nav, startCell, goalCell, options = {}) {
+  const path = findTilemapPath2D(nav, startCell, goalCell, options);
+  if (path.ok !== true || !path.nextCell) {
+    return {
+      ...path,
+      directionX: 0,
+      directionY: 0,
+    };
+  }
+
+  const start = normalizeCell(startCell);
+  if (!start || sameCell(start, path.nextCell)) {
+    return {
+      ...path,
+      directionX: 0,
+      directionY: 0,
+    };
+  }
+
+  const dx = path.nextCell.x - start.x;
+  const dy = path.nextCell.y - start.y;
+  const length = Math.hypot(dx, dy);
+  return {
+    ...path,
+    directionX: length > 0 ? dx / length : 0,
+    directionY: length > 0 ? dy / length : 0,
+  };
+}

package/src/helpers/starter-utils/tilemap-world-2d.js

@@ -0,0 +1,205 @@
+import { centeredRect } from './core.js';
+
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function normalizeText(value, fallback = null) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function resolveAura(auraRef = globalThis.aura) {
+  return auraRef && typeof auraRef === 'object' ? auraRef : null;
+}
+
+function toLocalPoint(world, point = {}) {
+  return {
+    x: finite(point.x) - finite(world?.offsetX),
+    y: finite(point.y) - finite(world?.offsetY),
+  };
+}
+
+function toWorldPoint(world, point = {}) {
+  return {
+    x: finite(point.x) + finite(world?.offsetX),
+    y: finite(point.y) + finite(world?.offsetY),
+  };
+}
+
+function toLocalAabb(world, bounds = {}) {
+  const point = toLocalPoint(world, bounds);
+  return {
+    x: point.x,
+    y: point.y,
+    w: Math.max(0, finite(bounds.w ?? bounds.width)),
+    h: Math.max(0, finite(bounds.h ?? bounds.height)),
+  };
+}
+
+function objectToWorldAnchor(world, object, centered = false) {
+  if (!object || typeof object !== 'object') return null;
+  const x = finite(object.x);
+  const y = finite(object.y);
+  const width = Math.max(0, finite(object.width));
+  const height = Math.max(0, finite(object.height));
+  return {
+    x: finite(world?.offsetX) + (centered && width > 0 ? x + (width * 0.5) : x),
+    y: finite(world?.offsetY) + (centered && height > 0 ? y + (height * 0.5) : y),
+    object,
+  };
+}
+
+function queryObjects(aura, world, options = {}) {
+  if (!ensureTilemapWorldLoaded2D(world, aura)) return [];
+  const result = aura.tilemap.queryObjects(world.mapId, options) || null;
+  return Array.isArray(result?.hits) ? result.hits : [];
+}
+
+export function createTilemapWorld2D(options = {}) {
+  return {
+    mapSource: options.mapSource ?? options.map ?? null,
+    mapId: Number.isInteger(Number(options.mapId)) && Number(options.mapId) > 0 ? Number(options.mapId) : 0,
+    info: null,
+    loaded: Number.isInteger(Number(options.mapId)) && Number(options.mapId) > 0,
+    offsetX: finite(options.offsetX ?? options.x),
+    offsetY: finite(options.offsetY ?? options.y),
+    cull: options.cull !== false,
+    includeHidden: options.includeHidden === true,
+    lastDrawSummary: null,
+  };
+}
+
+export function ensureTilemapWorldLoaded2D(world, auraRef = globalThis.aura) {
+  const aura = resolveAura(auraRef);
+  if (!world || !aura?.tilemap || typeof aura.tilemap.import !== 'function') return false;
+  if (world.loaded === true && Number.isInteger(Number(world.mapId)) && Number(world.mapId) > 0) {
+    return true;
+  }
+  const mapId = aura.tilemap.import(world.mapSource);
+  if (!Number.isInteger(Number(mapId)) || Number(mapId) <= 0) return false;
+  world.mapId = Number(mapId);
+  world.loaded = true;
+  world.info = typeof aura.tilemap.getInfo === 'function' ? aura.tilemap.getInfo(world.mapId) || null : null;
+  return true;
+}
+
+export function unloadTilemapWorld2D(world, auraRef = globalThis.aura) {
+  const aura = resolveAura(auraRef);
+  if (!world || !aura?.tilemap || typeof aura.tilemap.unload !== 'function') return false;
+  if (!Number.isInteger(Number(world.mapId)) || Number(world.mapId) <= 0) return false;
+  const unloaded = aura.tilemap.unload(world.mapId) === true;
+  if (!unloaded) return false;
+  world.mapId = 0;
+  world.loaded = false;
+  world.info = null;
+  world.lastDrawSummary = null;
+  return true;
+}
+
+export function drawTilemapWorld2D(world, auraRef = globalThis.aura, options = {}) {
+  const aura = resolveAura(auraRef);
+  if (!ensureTilemapWorldLoaded2D(world, aura) || typeof aura.tilemap.draw !== 'function') return null;
+  const summary = aura.tilemap.draw(world.mapId, {
+    x: finite(options.x, finite(world.offsetX)),
+    y: finite(options.y, finite(world.offsetY)),
+    cull: options.cull ?? world.cull,
+    camera: options.camera,
+    view: options.view,
+    includeHidden: options.includeHidden ?? world.includeHidden,
+  }) || null;
+  world.lastDrawSummary = summary;
+  return summary;
+}
+
+export function listTilemapWorldObjects2D(world, auraRef = globalThis.aura, options = {}) {
+  const aura = resolveAura(auraRef);
+  return queryObjects(aura, world, options).map((entry) => ({
+    ...entry,
+    worldX: finite(entry?.x) + finite(world?.offsetX),
+    worldY: finite(entry?.y) + finite(world?.offsetY),
+  }));
+}
+
+export function findTilemapWorldObject2D(world, auraRef = globalThis.aura, options = {}) {
+  return listTilemapWorldObjects2D(world, auraRef, options)[0] || null;
+}
+
+export function resolveTilemapSpawn2D(world, auraRef = globalThis.aura, options = {}) {
+  const normalized = typeof options === 'string' ? { name: options } : options;
+  const object = findTilemapWorldObject2D(world, auraRef, {
+    layer: normalized.layer,
+    name: normalized.name,
+    type: normalized.type ?? 'spawn',
+    className: normalized.className ?? normalized.class,
+    property: normalized.property,
+    properties: normalized.properties,
+    includeHidden: normalized.includeHidden,
+  });
+  if (!object) return null;
+  return objectToWorldAnchor(world, object, normalized.centered === true);
+}
+
+export function queryTilemapWorldPoint2D(world, auraRef = globalThis.aura, point = {}) {
+  const aura = resolveAura(auraRef);
+  if (!ensureTilemapWorldLoaded2D(world, aura) || typeof aura.tilemap.queryPoint !== 'function') return null;
+  return aura.tilemap.queryPoint(world.mapId, toLocalPoint(world, point)) || null;
+}
+
+export function queryTilemapWorldAABB2D(world, auraRef = globalThis.aura, bounds = {}) {
+  const aura = resolveAura(auraRef);
+  if (!ensureTilemapWorldLoaded2D(world, aura) || typeof aura.tilemap.queryAABB !== 'function') return null;
+  return aura.tilemap.queryAABB(world.mapId, toLocalAabb(world, bounds)) || null;
+}
+
+export function isTilemapPointBlocked2D(world, auraRef = globalThis.aura, point = {}) {
+  const result = queryTilemapWorldPoint2D(world, auraRef, point);
+  return result?.hit === true;
+}
+
+export function moveActorThroughTilemapWorld2D(
+  world,
+  auraRef = globalThis.aura,
+  actor = {},
+  dx = 0,
+  dy = 0,
+  width = 16,
+  height = width,
+) {
+  const stepX = finite(dx);
+  const stepY = finite(dy);
+  const actorWidth = Math.max(0.1, finite(width, 16));
+  const actorHeight = Math.max(0.1, finite(height, actorWidth));
+
+  const targetX = finite(actor.x) + stepX;
+  const targetY = finite(actor.y) + stepY;
+  const blockedX = queryTilemapWorldAABB2D(
+    world,
+    auraRef,
+    centeredRect(targetX, finite(actor.y), actorWidth, actorHeight),
+  )?.hit === true;
+  if (!blockedX) {
+    actor.x = targetX;
+  }
+
+  const blockedY = queryTilemapWorldAABB2D(
+    world,
+    auraRef,
+    centeredRect(finite(actor.x), targetY, actorWidth, actorHeight),
+  )?.hit === true;
+  if (!blockedY) {
+    actor.y = targetY;
+  }
+
+  return {
+    x: finite(actor.x),
+    y: finite(actor.y),
+    movedX: blockedX ? 0 : stepX,
+    movedY: blockedY ? 0 : stepY,
+    blockedX,
+    blockedY,
+  };
+}