《游戏引擎实现原理》6.1 为什么指针会失效

// file: src/core/dangling-demo.ts
// tier: L1
// verify: npx vitest run src/core/dangling-demo.test.ts
//
// 反例：用「裸索引」当句柄的实体表。对象被移除、槽位被复用后，
// 旧索引会读到「另一个对象」——这正是世代句柄要解决的问题。

export type Entity = { id: number; name: string; hp: number };

export class NaiveEntityTable {
  #items: (Entity | undefined)[] = [];

  /** 分配一个实体：优先复用空槽（模拟对象池）。返回裸索引。 */
  spawn(name: string, hp: number): number {
    for (let i = 0; i < this.#items.length; i++) {
      if (this.#items[i] === undefined) {
        this.#items[i] = { id: i, name, hp };
        return i;
      }
    }
    const index = this.#items.length;
    this.#items.push({ id: index, name, hp });
    return index;
  }

  kill(index: number): void {
    this.#items[index] = undefined;
  }

  /** 裸索引访问：没有任何「这个索引是否还指同一个对象」的校验。 */
  at(index: number): Entity | undefined {
    return this.#items[index];
  }

  get capacity(): number {
    return this.#items.length;
  }
}

// file: src/core/dangling-demo.test.ts
// tier: L1
// verify: npx vitest run src/core/dangling-demo.test.ts

import { describe, expect, it } from 'vitest';
import { NaiveEntityTable } from './dangling-demo.ts';

describe('裸索引句柄的失效问题', () => {
  it('对象被删后旧索引读到 undefined（最轻的一种失效）', () => {
    const t = new NaiveEntityTable();
    const slime = t.spawn('slime', 10);
    t.kill(slime);
    expect(t.at(slime)).toBeUndefined();
  });

  it('槽位复用后，旧索引读到「另一个对象」（最危险的一种失效）', () => {
    const t = new NaiveEntityTable();
    const slime = t.spawn('slime', 10);
    const wolf = t.spawn('wolf', 30);
    expect(slime).toBe(0);
    expect(wolf).toBe(1);

    // 击杀史莱姆，槽位 0 变空
    t.kill(slime);

    // 新生成的蝙蝠复用了槽位 0
    const bat = t.spawn('bat', 5);
    expect(bat).toBe(slime); // 同一个裸索引

    // 旧句柄 slime 现在读到的是蝙蝠，而不是 undefined，也不报错
    const stale = t.at(slime);
    expect(stale).toBeDefined();
    expect(stale!.name).toBe('bat');
    expect(stale!.hp).toBe(5);
  });

  it('裸索引既无法区分「空」与「新对象」，也无法在写入时暴露错误', () => {
    const t = new NaiveEntityTable();
    const a = t.spawn('a', 1);
    t.kill(a);
    const b = t.spawn('b', 2);
    // a 与 b 数值相等，语言层面无法分辨谁是谁
    expect(a === b).toBe(true);
    // 误写会静默改到 b 身上
    t.at(a)!.hp = 999;
    expect(t.at(b)!.hp).toBe(999);
  });
});

// file: src/core/ghost-demo.ts
// tier: L1
// verify: npx vitest run src/core/ghost-demo.test.ts
//
// 第三种失效：手里攥着「对象引用」而不是句柄。对象从表里移除后，
// 引用仍然可用（GC 不会回收），但对它的修改再也影响不到表——
// 这就是「幽灵对象」：看起来一切正常，写入却丢了。

export type GhostEntity = { id: number; name: string; hp: number };

export class GhostTable {
  #items: Map<number, GhostEntity> = new Map();
  #next = 0;

  /** 返回对象引用本身（而不是句柄）。 */
  spawn(name: string, hp: number): GhostEntity {
    const e = { id: this.#next++, name, hp };
    this.#items.set(e.id, e);
    return e;
  }

  kill(id: number): void {
    this.#items.delete(id);
  }

  count(): number {
    return this.#items.size;
  }

  /** 表内所有实体血量之和，用来观察「幽灵写入」是否真的丢了。 */
  totalHp(): number {
    let sum = 0;
    for (const e of this.#items.values()) sum += e.hp;
    return sum;
  }
}

// file: src/core/ghost-demo.test.ts
// tier: L1
// verify: npx vitest run src/core/ghost-demo.test.ts

import { describe, expect, it } from 'vitest';
import { GhostTable } from './ghost-demo.ts';

describe('对象引用作为句柄的幽灵问题', () => {
  it('删除后引用仍可写，但写不回表里', () => {
    const t = new GhostTable();
    const slime = t.spawn('slime', 10);
    t.kill(slime.id);
    expect(t.count()).toBe(0);

    // 引用没失效：还能读、还能写
    slime.hp = 999;
    expect(slime.hp).toBe(999);

    // 但表里已经没有任何实体，写入彻底丢失
    expect(t.totalHp()).toBe(0);
  });

  it('幽灵对象不会报错，只会让逻辑静默走偏', () => {
    const t = new GhostTable();
    const a = t.spawn('a', 1);
    t.kill(a.id);
    // 没有异常、没有 undefined，只有「看起来改了」
    expect(() => {
      a.hp += 100;
    }).not.toThrow();
    expect(t.count()).toBe(0);
  });
});