经典捕鱼游戏街机版核心算法拆解：七星金币捕鱼碰撞与倍率系统全开源

// collision/satCollision.ts
export interface Polygon {
  vertices: Vec2[]; // 按逆时针排列的顶点
}

export interface OBB {
  center: Vec2;
  halfWidth: number;
  halfHeight: number;
  angle: number; // 弧度
}

// 子弹OBB与鱼多边形碰撞
export function testBulletFish(bullet: OBB, fish: Polygon): boolean {
  // 将OBB转换为4个顶点
  const bulletVerts = getOBBVertices(bullet);
  // 合并所有分离轴：子弹的2条边法线 + 鱼多边形的所有边法线
  const axes: Vec2[] = [];
  addOBBAxes(bullet, axes);
  addPolygonAxes(fish.vertices, axes);

  for (const axis of axes) {
    const projA = projectPolygon(bulletVerts, axis);
    const projB = projectPolygon(fish.vertices, axis);
    if (projA.max < projB.min || projB.max < projA.min) {
      return false; // 分离轴存在，无碰撞
    }
  }
  return true;
}

function getOBBVertices(obb: OBB): Vec2[] {
  const hw = obb.halfWidth, hh = obb.halfHeight;
  const cos = Math.cos(obb.angle), sin = Math.sin(obb.angle);
  return [
    new Vec2(obb.center.x + hw*cos - hh*sin, obb.center.y + hw*sin + hh*cos),
    new Vec2(obb.center.x + hw*cos + hh*sin, obb.center.y + hw*sin - hh*cos),
    new Vec2(obb.center.x - hw*cos + hh*sin, obb.center.y - hw*sin - hh*cos),
    new Vec2(obb.center.x - hw*cos - hh*sin, obb.center.y - hw*sin + hh*cos)
  ];
}

function projectPolygon(verts: Vec2[], axis: Vec2): { min: number; max: number } {
  let min = Infinity, max = -Infinity;
  for (const v of verts) {
    const dot = v.x * axis.x + v.y * axis.y;
    if (dot < min) min = dot;
    if (dot > max) max = dot;
  }
  return { min, max };
}

// fish/FishPathController.ts
export class FishPathController {
  private t: number = 0;
  private speed: number;
  private controlPoints: Vec2[]; // P0, P1, P2, P3
  private onPathEnd: () => void;

  constructor(startPos: Vec2, speed: number, bounds: Rect, onEnd: () => void) {
    this.speed = speed;
    this.onPathEnd = onEnd;
    this.generateNewPath(startPos, bounds);
  }

  // 在屏幕边界内随机生成下一段贝塞尔控制点
  private generateNewPath(from: Vec2, bounds: Rect): void {
    const P0 = from;
    const P1 = new Vec2(from.x + randomRange(-200, 200), from.y + randomRange(-150, 150));
    const P3 = new Vec2(
      randomRange(bounds.xMin + 50, bounds.xMax - 50),
      randomRange(bounds.yMin + 50, bounds.yMax - 50)
    );
    const P2 = new Vec2(
      (P1.x + P3.x) / 2 + randomRange(-100, 100),
      (P1.y + P3.y) / 2 + randomRange(-100, 100)
    );
    this.controlPoints = [P0, P1, P2, P3];
    this.t = 0;
  }

  // 每帧更新，返回当前位置和角度
  update(dt: number): { pos: Vec2; angle: number } {
    this.t += this.speed * dt;
    if (this.t >= 1) {
      this.generateNewPath(this.controlPoints[3], /* bounds */);
    }
    const pos = bezierPoint(this.controlPoints, Math.min(this.t, 1));
    const angle = bezierTangentAngle(this.controlPoints, Math.min(this.t, 1));
    return { pos, angle };
  }
}

function bezierPoint(cp: Vec2[], t: number): Vec2 {
  const u = 1 - t;
  return new Vec2(
    u*u*u*cp[0].x + 3*u*u*t*cp[1].x + 3*u*t*t*cp[2].x + t*t*t*cp[3].x,
    u*u*u*cp[0].y + 3*u*u*t*cp[1].y + 3*u*t*t*cp[2].y + t*t*t*cp[3].y
  );
}

function bezierTangentAngle(cp: Vec2[], t: number): number {
  const u = 1 - t;
  const dx = 3*u*u*(cp[1].x - cp[0].x) + 6*u*t*(cp[2].x - cp[1].x) + 3*t*t*(cp[3].x - cp[2].x);
  const dy = 3*u*u*(cp[1].y - cp[0].y) + 6*u*t*(cp[2].y - cp[1].y) + 3*t*t*(cp[3].y - cp[2].y);
  return Math.atan2(dy, dx);
}

// economy/PayoutController.ts
export class PayoutController {
  private roomPool: number;        // 房间总金币池
  private playerLuckFactor: Map<string, number> = new Map();

  // 击杀一条鱼时调用，返回实际发放金币
  calcPayout(fishType: FishType, playerId: string): number {
    const basePayout = FISH_BASE_PAYOUT[fishType]; // 基础倍率表
    // 1. 房间水位调节：池子太满就降低倍率，太空则提高
    const roomFactor = this.calcRoomFactor();
    // 2. 个人幸运值：最近连续不中的玩家微幅提升倍率
    const luckFactor = this.getLuckFactor(playerId);
    // 3. 浮动区间随机 [-8%, +8%]
    const randomFactor = 0.92 + Math.random() * 0.16;
    
    const finalPayout = Math.round(basePayout * roomFactor * luckFactor * randomFactor);
    this.roomPool -= finalPayout;
    this.updateLuckFactor(playerId, finalPayout >= basePayout);
    return Math.max(finalPayout, 1); // 保底1金币
  }

  private calcRoomFactor(): number {
    const targetPool = 500000; // 目标水位
    const ratio = this.roomPool / targetPool;
    if (ratio > 1.3) return 0.85;  // 池子太满，收紧
    if (ratio < 0.7) return 1.15;  // 池子太空，放水
    return 1.0;
  }
}

// skill/SkillManager.ts
export enum SkillType { LASER = 'laser', FREEZE = 'freeze' }

export function activateSkill(skill: SkillType, fishes: Fish[], bullets: Bullet[]): void {
  switch (skill) {
    case SkillType.LASER:
      fishes.forEach(f => {
        if (f.alive) {
          f.takeDamage(9999); // 秒杀伤害
          playEffect('laser_beam', f.position);
        }
      });
      break;
    case SkillType.FREEZE:
      fishes.forEach(f => f.frozen = true);
      setTimeout(() => fishes.forEach(f => f.frozen = false), 3000);
      break;
  }
}