Teil 3: Auf Blöcken gehen

import { CELL, type Block, type BlockStore } from './blocks.ts';
import { covered, SIDES } from './blockMesher.ts';
import type { Field } from './field.ts';

/** The nearest surface to a point: how far away it is, and which way is out. */
export interface Surface {
  /** Meters from the point to the surface, below 0 inside a solid. */
  distance: number;
  /** One meter long, pointing out of the solid. */
  normal: [number, number, number];
}

/**
 * The distance from a point to a block, below 0 inside it: a signed distance. Each axis
 * says how far the point is outside the block's slab along it; outside the box, the
 * distance is the length of those that are above 0, inside it the largest of them.
 * Inside, the way out is through the nearest side for which `isOpen(side)` says yes,
 * by the side's number in SIDES.
 */
export function blockDistance(
  block: Block,
  x: number,
  y: number,
  z: number,
  isOpen: (side: number) => boolean = () => true,
): Surface {
  const half = (block.size * CELL) / 2;
  // From the block's middle.
  const p = [x - block.x * CELL - half, y - block.y * CELL - half, z - block.z * CELL - half];
  const q = p.map((c) => Math.abs(c) - half);
  const outside = q.map((c) => Math.max(c, 0));
  const length = Math.hypot(...outside);
  if (length > 0) {
    // Out from the nearest point of the box.
    const normal = outside.map((c, axis) => (c / length) * Math.sign(p[axis]));
    return { distance: length, normal: normal as Surface['normal'] };
  }
  // Inside: out through the nearest open side, or up (side 3) if none is open. Each
  // side's plane is dir × p[axis] - half away, below 0 since the point is inside.
  let side = 3;
  let distance = -Infinity;
  SIDES.forEach(({ axis, dir }, s) => {
    const d = dir * p[axis] - half;
    if (d > distance && isOpen(s)) {
      side = s;
      distance = d;
    }
  });
  if (distance === -Infinity) distance = p[1] - half;
  const normal: Surface['normal'] = [0, 0, 0];
  normal[SIDES[side].axis] = SIDES[side].dir;
  return { distance, normal };
}

/** Everything solid: the terrain and the blocks. */
export class Solids {
  private readonly field: Field;
  private readonly store: BlockStore;

  constructor(field: Field, store: BlockStore) {
    this.field = field;
    this.store = store;
  }

  /** The nearest surface to a point, if one is within `reach` meters. */
  nearest(x: number, y: number, z: number, reach: number): Surface | null {
    let nearest: Surface | null = null;
    // The terrain: its density over how fast the density changes is about the distance
    // to its surface, as the player worked it out so far.
    const { density, gradient } = this.field.probe(x, y, z);
    const steepness = Math.hypot(...gradient);
    if (steepness > 0 && -density / steepness < reach) {
      const normal = gradient.map((g) => -g / steepness) as Surface['normal'];
      nearest = { distance: -density / steepness, normal };
    }
    // The blocks with a cell within reach, each once.
    const seen = new Set<Block>();
    const from = (c: number) => Math.floor((c - reach) / CELL);
    const to = (c: number) => Math.floor((c + reach) / CELL);
    for (let k = from(z); k <= to(z); k += 1) {
      for (let j = from(y); j <= to(y); j += 1) {
        for (let i = from(x); i <= to(x); i += 1) {
          const block = this.store.at(i, j, k);
          if (!block || seen.has(block)) continue;
          seen.add(block);
          // Out of a block only where no other block fills the cells beyond.
          const surface = blockDistance(block, x, y, z, (side) => !covered(this.store, block, SIDES[side]));
          if (surface.distance < reach && (!nearest || surface.distance < nearest.distance)) nearest = surface;
        }
      }
    }
    return nearest;
  }
}

/** The body: two balls of this radius, one at the feet and one at the head. */
export const RADIUS = 0.4;
export const HEIGHT = 1.8;

/** A body that walks on the terrain and the blocks, with no physics engine. */
export class Player {
  /** Where the feet are. */
  readonly position: Vector3;
  readonly velocity = new Vector3();
  grounded = false;
  private readonly solids: Solids;

  constructor(solids: Solids, feet: Vector3) {
    this.solids = solids;
    this.position = feet.clone();
  }

/** Pushes both balls out of the ground and the blocks. */
private collide(): void {
  this.grounded = false;
  for (let pass = 0; pass < 3; pass += 1) {
    for (const height of [RADIUS, HEIGHT - RADIUS]) {
      const surface = this.solids.nearest(
        this.position.x,
        this.position.y + height,
        this.position.z,
        RADIUS,
      );
      if (!surface) continue;
      const depth = RADIUS - surface.distance;
      const normal = new Vector3(...surface.normal);
      if (normal.y > WALKABLE) {
        // Ground: straight up, so that the player doesn't slide down a slope.
        this.position.y += depth / normal.y;
        this.velocity.y = Math.max(this.velocity.y, 0);
        this.grounded = true;
      } else {
        // A wall or a ceiling: back out along the normal, and stop moving into it.
        this.position.addInPlace(normal.scale(depth));
        const into = Vector3.Dot(this.velocity, normal);
        if (into < 0) this.velocity.subtractInPlace(normal.scale(into));
      }
    }
  }
}

/** Whether a block may go somewhere, besides fitting between the other blocks. */
canPlace: (block: Block) => boolean = () => true;

const fits = this.store.fits(block.x, block.y, block.z, block.size) && this.canPlace(block);

const player = new Player(new Solids(new Field(world.edits), blocks.store), feet);

// A block may not go where the player stands: balls at the feet, the middle and the head
// must stay clear of it. Flying, the camera goes through anything.
blockTool.canPlace = (block) => {
  if (mode === 'fly') return true;
  const { x, y, z } = player.position;
  return [RADIUS, HEIGHT / 2, HEIGHT - RADIUS].every(
    (height) => blockDistance(block, x, y + height, z).distance >= RADIUS,
  );
};