《Cocos 游戏开发入门》7.3 碰撞响应、触发器与分层掩码

// mini2d/src/physics/mtv.ts
import type { AABB } from './shapes';

export interface Vec2 {
  x: number;
  y: number;
}

export interface MTV {
  /** 把 a 推离 b 的单位方向。 */
  readonly normal: Vec2;
  /** 需要推出的距离（重叠深度）。 */
  readonly depth: number;
}

/** 若 a 与 b 重叠，返回把 a 推离 b 的最小平移向量；否则返回 null。 */
export function resolveAABB(a: AABB, b: AABB): MTV | null {
  const dx = b.center.x - a.center.x;
  const ox = a.half.x + b.half.x - Math.abs(dx);
  if (ox <= 0) return null;

  const dy = b.center.y - a.center.y;
  const oy = a.half.y + b.half.y - Math.abs(dy);
  if (oy <= 0) return null;

  if (ox < oy) {
    // x 轴穿透更浅：沿 x 推出。dx > 0 表示 b 在 a 右侧，a 应向左退。
    return { normal: { x: dx < 0 ? 1 : -1, y: 0 }, depth: ox };
  }
  return { normal: { x: 0, y: dy < 0 ? 1 : -1 }, depth: oy };
}

export function applyMTV(a: AABB, mtv: MTV): AABB {
  return {
    center: {
      x: a.center.x + mtv.normal.x * mtv.depth,
      y: a.center.y + mtv.normal.y * mtv.depth,
    },
    half: a.half,
  };
}

export interface Body {
  readonly id: number;
  aabb: AABB;
  velocity: Vec2;
  layer: number;
  mask: number;
  isStatic: boolean;
  isTrigger: boolean;
  mass: number;
}

/** 按质量与静态性分配 MTV 位移，返回两个物体各自的新 AABB。 */
export function distributeMTV(
  a: Body,
  b: Body,
  mtv: MTV,
): { a: AABB; b: AABB } {
  if (a.isStatic && b.isStatic) {
    return { a: a.aabb, b: b.aabb }; // 两个都不动，交给上层决定
  }
  if (a.isStatic) {
    return { a: a.aabb, b: applyMTV(b.aabb, { normal: negate(mtv.normal), depth: mtv.depth }) };
  }
  if (b.isStatic) {
    return { a: applyMTV(a.aabb, mtv), b: b.aabb };
  }
  // 都动态：按质量反比分配
  const total = a.mass + b.mass;
  const aShare = b.mass / total;
  const bShare = a.mass / total;
  return {
    a: applyMTV(a.aabb, { normal: mtv.normal, depth: mtv.depth * aShare }),
    b: applyMTV(b.aabb, { normal: negate(mtv.normal), depth: mtv.depth * bShare }),
  };
}

function negate(v: Vec2): Vec2 {
  return { x: -v.x, y: -v.y };
}

/** 返回 [0,1] 内的首次碰撞时间；无碰撞返回 null。 */
export function sweptAABB(a: AABB, vel: Vec2, b: AABB, dt: number): number | null {
  const ex = b.half.x + a.half.x;
  const ey = b.half.y + a.half.y;
  const dx = b.center.x - a.center.x;
  const dy = b.center.y - a.center.y;
  const vx = vel.x * dt;
  const vy = vel.y * dt;

  let tEnter = -Infinity;
  let tExit = Infinity;

  if (vx !== 0) {
    const t1 = (-ex - dx) / vx;
    const t2 = (ex - dx) / vx;
    tEnter = Math.max(tEnter, Math.min(t1, t2));
    tExit = Math.min(tExit, Math.max(t1, t2));
  } else if (Math.abs(dx) > ex) {
    return null; // x 方向不动且已分离
  }

  if (vy !== 0) {
    const t1 = (-ey - dy) / vy;
    const t2 = (ey - dy) / vy;
    tEnter = Math.max(tEnter, Math.min(t1, t2));
    tExit = Math.min(tExit, Math.max(t1, t2));
  } else if (Math.abs(dy) > ey) {
    return null;
  }

  if (tEnter > tExit || tEnter > 1 || tExit < 0) return null;
  return Math.max(tEnter, 0);
}

// 在 7.2 的 Body 基础上补上 velocity / isTrigger / mass
export interface Body {
  readonly id: number;
  aabb: AABB;
  velocity: Vec2;
  layer: number;
  mask: number;
  isStatic: boolean;
  isTrigger: boolean;
  mass: number;
}

export interface Contact {
  readonly a: Body;
  readonly b: Body;
  readonly phase: 'begin' | 'stay' | 'end';
}

export function respond(a: Body, b: Body, mtv: MTV | null): Contact | null {
  if (mtv === null) return null;

  if (a.isTrigger || b.isTrigger) {
    // 触发器不参与位置修正，只产生事件
    return { a, b, phase: 'begin' };
  }

  const moved = distributeMTV(a, b, mtv);
  a.aabb = moved.a;
  b.aabb = moved.b;
  return null; // 物理响应不产生事件（需要时另行上报）
}

export const LAYER = {
  Player: 1 << 0, // 1
  Enemy: 1 << 1, // 2
  Ground: 1 << 2, // 4
  Pickup: 1 << 3, // 8
  Bullet: 1 << 4, // 16
} as const;

export function canCollide(a: Body, b: Body): boolean {
  return (a.mask & b.layer) !== 0 && (b.mask & a.layer) !== 0;
}

// 接在 7.2 的 Broadphase.collect 之后
export function filterAndResolve(candidates: Array<[Body, Body]>): Contact[] {
  const contacts: Contact[] = [];
  for (const [a, b] of candidates) {
    if (!canCollide(a, b)) continue;
    const c = respond(a, b, resolveAABB(a.aabb, b.aabb));
    if (c) contacts.push(c);
  }
  return contacts;
}

import { _decorator, Component, RigidBody2D, ERigidBody2DType } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('PlayerBody')
export class PlayerBody extends Component {
  @property(RigidBody2D)
  body: RigidBody2D | null = null;

  onLoad(): void {
    const rb = this.body;
    if (!rb) return;
    rb.type = ERigidBody2DType.Dynamic;
    rb.gravityScale = 1;
    rb.fixedRotation = true; // 2D 横版角色不翻滚
    rb.bullet = true; // 抗隧道，等价于我们的 sweptAABB 开关
  }
}

import { _decorator, Component, Collider2D, Contact2DType, IPhysics2DContact } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('Pickup')
export class Pickup extends Component {
  @property
  score = 1;

  private collider: Collider2D | null = null;

  onEnable(): void {
    this.collider = this.getComponent(Collider2D);
    this.collider?.on(Contact2DType.BEGIN_CONTACT, this.onBegin, this);
  }

  onDisable(): void {
    this.collider?.off(Contact2DType.BEGIN_CONTACT, this.onBegin, this);
  }

  private onBegin(self: Collider2D, other: Collider2D, contact: IPhysics2DContact | null): void {
    // 触发器只在这一刻报一次事件，不推物体
    console.log('吃到金币', self.node.name, other.node.name, this.score, contact !== null);
  }
}