《Cocos 游戏联机实战》3.2 兴趣管理与 AOI

// mini2d/net/aoi.ts —— 纯 TS，无 cc 依赖
export interface Rect {
  x: number;
  y: number;
  w: number;
  h: number;
}

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

/** 点是否落在矩形内（含边界） */
export function inRect(p: Point, r: Rect): boolean {
  return p.x >= r.x && p.x <= r.x + r.w && p.y >= r.y && p.y <= r.y + r.h;
}

/**
 * 带滞回带的视野判定。
 * 已可见：只有移出「外扩 hysteresis 的外矩形」才算离开；
 * 不可见：必须进入「内矩形（视口本身）」才算进入。
 */
export function inView(p: Point, view: Rect, hysteresis: number, wasVisible: boolean): boolean {
  if (wasVisible) {
    const outer: Rect = {
      x: view.x - hysteresis,
      y: view.y - hysteresis,
      w: view.w + hysteresis * 2,
      h: view.h + hysteresis * 2,
    };
    return inRect(p, outer);
  }
  return inRect(p, view);
}

export interface AoiDiff {
  enter: number[];
  leave: number[];
}

/** 计算「上一帧可见集 → 这一帧可见集」的进出差集 */
export function diffView(
  prev: Set<number>,
  positions: Map<number, Point>,
  view: Rect,
  hysteresis: number,
): AoiDiff {
  const enter: number[] = [];
  const leave: number[] = [];
  const now = new Set<number>();
  for (const [id, p] of positions) {
    if (inView(p, view, hysteresis, prev.has(id))) {
      now.add(id);
      if (!prev.has(id)) {
        enter.push(id);
      }
    }
  }
  for (const id of prev) {
    if (!now.has(id)) {
      leave.push(id);
    }
  }
  return { enter, leave };
}

import { describe, expect, it } from 'vitest';
import { diffView, inView, type Rect } from './aoi';

const view: Rect = { x: 0, y: 0, w: 100, h: 100 };

describe('AOI 视野与滞回带', () => {
  it('已可见的实体，需越过外扩带才离开', () => {
    const nearEdge = { x: 105, y: 50 }; // 出内矩形、但在 10px 滞回带内
    expect(inView(nearEdge, view, 10, true)).toBe(true);   // 仍算可见，不触发离开
    expect(inView(nearEdge, view, 10, false)).toBe(false); // 本不可见则不算进入
    const far = { x: 120, y: 50 };      // 越过外扩带
    expect(inView(far, view, 10, true)).toBe(false);
  });

  it('进出差集只报变化项', () => {
    const prev = new Set<number>([1, 2]);
    const positions = new Map<number, { x: number; y: number }>([
      [1, { x: 50, y: 50 }],  // 仍在视野
      [2, { x: 200, y: 50 }], // 离开
      [3, { x: 20, y: 20 }],  // 进入
    ]);
    const d = diffView(prev, positions, view, 10);
    expect(d.enter).toEqual([3]);
    expect(d.leave).toEqual([2]);
  });
});

import { _decorator, Component, Node, Prefab, instantiate } from 'cc';
const { ccclass, property } = _decorator;

@ccclass('AoiViewPool')
export class AoiViewPool extends Component {
  @property(Prefab)
  public entityPrefab: Prefab | null = null;

  private readonly free: Node[] = [];
  private readonly live = new Map<number, Node>();

  /** 实体进入视野：优先复用池中节点，没有则实例化 */
  onEnter(id: number, x: number, y: number): void {
    if (this.live.has(id)) {
      return;
    }
    let node = this.free.pop();
    if (!node && this.entityPrefab) {
      node = instantiate(this.entityPrefab);
      node.parent = this.node;
    }
    if (!node) {
      return;
    }
    node.active = true;
    node.setPosition(x, y, 0);
    this.live.set(id, node);
  }

  /** 实体离开视野：停用并回收，不销毁 */
  onLeave(id: number): void {
    const node = this.live.get(id);
    if (!node) {
      return;
    }
    node.active = false;
    this.live.delete(id);
    this.free.push(node);
  }
}