《Cocos 游戏开发实战》8.3 程序化关卡与难度曲线

// assets/scripts/core/rng.ts
export type Rng = () => number;

/** mulberry32：32 位种子、确定性、分布均匀，适合关卡生成。 */
export function makeRng(seed: number): Rng {
  let a = seed >>> 0;
  return () => {
    a = (a + 0x6d2b79f5) >>> 0;
    let t = a;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

/** 从数组里等概率取一个元素。 */
export function pick<T>(rng: Rng, list: readonly T[]): T {
  return list[Math.floor(rng() * list.length)];
}

/** 取闭区间 [min, max] 内的整数。 */
export function rangeInt(rng: Rng, min: number, max: number): number {
  return min + Math.floor(rng() * (max - min + 1));
}

// assets/scripts/core/difficulty.ts
export interface DifficultyBand {
  /** 起始关卡序号（从 0 开始）。 */
  from: number;
  /** 关卡滚动速度，像素/秒。 */
  speed: number;
  /** 障碍之间的平均间距，像素。 */
  gap: number;
  /** 危险构件（尖刺、锯片）在障碍里的占比，0–1。 */
  hazardRatio: number;
  /** 需要跳过去的沟宽上限，像素。 */
  maxGapWidth: number;
}

const BANDS: DifficultyBand[] = [
  { from: 0,  speed: 300, gap: 420, hazardRatio: 0.00, maxGapWidth: 120 },
  { from: 5,  speed: 320, gap: 380, hazardRatio: 0.15, maxGapWidth: 150 },
  { from: 10, speed: 350, gap: 340, hazardRatio: 0.30, maxGapWidth: 175 },
  { from: 20, speed: 380, gap: 300, hazardRatio: 0.45, maxGapWidth: 190 },
  { from: 30, speed: 420, gap: 280, hazardRatio: 0.55, maxGapWidth: 200 },
];

export function bandFor(index: number): DifficultyBand {
  let current = BANDS[0];
  for (const band of BANDS) {
    if (index >= band.from) current = band;
  }
  return current;
}

// assets/scripts/core/jump-arc.ts（续 7.3）
/** 一次跳跃能覆盖的最大水平距离，像素。 */
export function maxJumpDistance(v0: number, gravity: number, runSpeed: number): number {
  return ((2 * v0) / gravity) * runSpeed;
}

// assets/scripts/core/generate-level.ts
import { makeRng, rangeInt } from './rng';
import { bandFor } from './difficulty';
import { maxJumpDistance } from './jump-arc';
import type { LevelDef, ObstacleDef, CoinDef } from './level-def';

const GROUND_Y = -150;
const V0 = 900;
const GRAVITY = 3000;

export function generateLevel(seed: number, index: number): LevelDef {
  const band = bandFor(index);
  const rng = makeRng(seed + index * 7919);
  const reach = maxJumpDistance(V0, GRAVITY, band.speed);
  const maxGap = Math.min(band.maxGapWidth, Math.floor(reach * 0.9));
  const obstacles: ObstacleDef[] = [];
  const coins: CoinDef[] = [];
  const goalX = 2400 + index * 240;

  let x = 600;
  while (x < goalX - 300) {
    const isHazard = rng() < band.hazardRatio;
    if (isHazard) {
      obstacles.push({ type: 'spike', x, y: GROUND_Y + 20, w: 40, h: 30 });
    } else {
      obstacles.push({ type: 'block', x, y: GROUND_Y + 30, w: rangeInt(rng, 120, 240), h: 40 });
    }
    const count = rangeInt(rng, 1, 3);
    for (let i = 0; i < count; i += 1) {
      coins.push({ x: x + i * 60, y: 40 + Math.round(rng() * 60) });
    }
    x += rangeInt(rng, band.gap, band.gap + 120);
  }

  return { id: `proc-${index + 1}`, name: `程序关 ${index + 1}`, speed: band.speed, goalX, obstacles, coins };
}

// assets/scripts/game/level-builder.ts
import { _decorator, Component, Node, Prefab, instantiate, Vec3 } from 'cc';
const { ccclass, property } = _decorator;

interface ObstacleDef { type: string; x: number; y: number; }
interface CoinDef { x: number; y: number; }
interface BuiltLevel { obstacles: ObstacleDef[]; coins: CoinDef[]; }

@ccclass('LevelBuilder')
export class LevelBuilder extends Component {
  @property({ type: Prefab }) blockPrefab: Prefab | null = null;
  @property({ type: Prefab }) spikePrefab: Prefab | null = null;
  @property({ type: Prefab }) coinPrefab: Prefab | null = null;

  private readonly pool = new Map<string, Prefab | null>();

  onLoad(): void {
    this.pool.set('block', this.blockPrefab);
    this.pool.set('spike', this.spikePrefab);
    this.pool.set('coin', this.coinPrefab);
  }

  build(level: BuiltLevel): void {
    for (const ob of level.obstacles) this.place(ob.type, ob.x, ob.y);
    for (const c of level.coins) this.place('coin', c.x, c.y);
  }

  private place(kind: string, x: number, y: number): Node | null {
    const prefab = this.pool.get(kind) ?? null;
    if (!prefab) return null;
    const node = instantiate(prefab);
    node.setParent(this.node);
    node.setPosition(new Vec3(x, y, 0));
    return node;
  }
}

[
  { "__type__": "cc.Prefab", "_name": "Spike", "data": { "__id__": 1 } },
  {
    "__type__": "cc.Node",
    "_name": "Spike",
    "_parent": null,
    "_children": [],
    "_components": [ { "__id__": 2 }, { "__id__": 3 }, { "__id__": 4 } ],
    "_lpos": { "__type__": "cc.Vec3", "x": 0, "y": 0, "z": 0 },
    "_layer": 33554432
  },
  {
    "__type__": "cc.UITransform",
    "node": { "__id__": 1 },
    "_contentSize": { "__type__": "cc.Size", "width": 40, "height": 30 },
    "_anchorPoint": { "__type__": "cc.Vec2", "x": 0.5, "y": 0.5 }
  },
  {
    "__type__": "cc.BoxCollider2D",
    "node": { "__id__": 1 },
    "size": { "__type__": "cc.Size", "width": 40, "height": 30 },
    "offset": { "__type__": "cc.Vec2", "x": 0, "y": 0 },
    "sensor": false,
    "group": 3
  },
  {
    "__type__": "Hazard",
    "node": { "__id__": 1 },
    "sceneName": "main"
  }
]