Claude 3.7：真正的"全能型战士"大模型，现已在国内可直接使用

使用 p5.js（无需 HTML）创建 10 个彩色球在旋转六边形内弹跳的效果，考虑重力，弹性，摩擦和碰撞。

let balls = [];
let hexagon;
let gravity;
let rotationSpeed = 0.005;

functionsetup() {
  createCanvas(600, 600);

  // 创建六边形
  hexagon = new Hexagon(width/2, height/2, 200);

  // 创建引力向量
  gravity = createVector(0, 0.2);

  // 创建 10 个彩色球
for (let i = 0; i < 10; i++) {
    let radius = random(15, 30);
    let x = random(width/2 - 100, width/2 + 100);
    let y = random(height/2 - 100, height/2 + 100);
    let vel = p5.Vector.random2D().mult(random(2, 5));
    let color = [random(100, 255), random(100, 255), random(100, 255)];
    balls.push(new Ball(x, y, radius, vel, color));
  }
}

functiondraw() {
  background(30);

  // 更新六边形旋转角度
  hexagon.update();

  // 显示六边形
  hexagon.display();

  // 更新和显示球
for (let ball of balls) {
    ball.applyForce(gravity);
    ball.update();
    ball.checkCollision(hexagon);
    
    // 检查球之间的碰撞
    for (let other of balls) {
      if (ball !== other) {
        ball.checkBallCollision(other);
      }
    }
    
    ball.display();
  }
}

class Ball {
  constructor(x, y, radius, vel, color) {
    this.pos = createVector(x, y);
    this.vel = vel;
    this.acc = createVector(0, 0);
    this.radius = radius;
    this.color = color;
    this.elasticity = random(0.7, 0.9);
    this.friction = 0.98;
  }

  applyForce(force) {
    this.acc.add(force);
  }

update() {
    this.vel.add(this.acc);
    this.vel.mult(this.friction);
    this.pos.add(this.vel);
    this.acc.set(0, 0);
  }

display() {
    noStroke();
    fill(this.color);
    ellipse(this.pos.x, this.pos.y, this.radius * 2);
  }

  checkCollision(hexagon) {
    // 获取六边形的顶点
    let vertices = hexagon.getVertices();
    
    // 检查与六边形的每条边的碰撞
    for (let i = 0; i < vertices.length; i++) {
      let start = vertices[i];
      let end = vertices[(i + 1) % vertices.length];
      
      // 计算球到线段的最近点
      let closest = this.closestPointOnLine(start, end);
      let distance = p5.Vector.dist(this.pos, closest);
      
      // 如果距离小于半径，发生碰撞
      if (distance < this.radius) {
        // 计算法线向量
        let normal = p5.Vector.sub(this.pos, closest).normalize();
        
        // 计算球的反弹
        let dotProduct = this.vel.dot(normal);
        let reflection = p5.Vector.mult(normal, dotProduct * 2);
        this.vel.sub(reflection);
        this.vel.mult(this.elasticity);
        
        // 稍微将球移出边界以防止粘连
        let correction = p5.Vector.mult(normal, this.radius - distance);
        this.pos.add(correction);
      }
    }
  }

  closestPointOnLine(lineStart, lineEnd) {
    let line = p5.Vector.sub(lineEnd, lineStart);
    let len = line.mag();
    line.normalize();
    
    let v = p5.Vector.sub(this.pos, lineStart);
    let d = v.dot(line);
    d = constrain(d, 0, len);
    
    return p5.Vector.add(lineStart, p5.Vector.mult(line, d));
  }

  checkBallCollision(other) {
    let distance = p5.Vector.dist(this.pos, other.pos);
    let minDist = this.radius + other.radius;
    
    if (distance < minDist) {
      // 计算碰撞法线
      let normal = p5.Vector.sub(this.pos, other.pos).normalize();
      
      // 计算相对速度
      let relativeVelocity = p5.Vector.sub(this.vel, other.vel);
      let velAlongNormal = relativeVelocity.dot(normal);
      
      // 如果球体相对于彼此远离，则不处理碰撞
      if (velAlongNormal > 0) return;
      
      // 计算反弹速度
      let e = (this.elasticity + other.elasticity) / 2;
      let j = -(1 + e) * velAlongNormal;
      j /= 1/this.radius + 1/other.radius;
      
      // 应用冲量
      let impulse = p5.Vector.mult(normal, j);
      
      // 使用质量（半径）来计算速度变化
      let thisImpulse = p5.Vector.div(impulse, this.radius);
      let otherImpulse = p5.Vector.div(impulse, other.radius);
      
      this.vel.add(thisImpulse);
      other.vel.sub(otherImpulse);
      
      // 防止球体重叠
      let overlap = minDist - distance;
      let correction = p5.Vector.mult(normal, overlap / 2);
      this.pos.add(correction);
      other.pos.sub(correction);
    }
  }
}

class Hexagon {
  constructor(x, y, size) {
    this.pos = createVector(x, y);
    this.size = size;
    this.rotation = 0;
  }

update() {
    this.rotation += rotationSpeed;
  }

getVertices() {
    let vertices = [];
    for (let i = 0; i < 6; i++) {
      let angle = this.rotation + i * TWO_PI / 6;
      let vx = this.pos.x + cos(angle) * this.size;
      let vy = this.pos.y + sin(angle) * this.size;
      vertices.push(createVector(vx, vy));
    }
    return vertices;
  }

display() {
    push();
    translate(this.pos.x, this.pos.y);
    rotate(this.rotation);
    
    // 绘制六边形
    stroke(200, 200, 255);
    strokeWeight(2);
    noFill();
    beginShape();
    for (let i = 0; i < 6; i++) {
      let angle = i * TWO_PI / 6;
      let vx = cos(angle) * this.size;
      let vy = sin(angle) * this.size;
      vertex(vx, vy);
    }
    endShape(CLOSE);
    
    pop();
  }
}

用 p5js 生成 Mandelbrot set.

分析这份文档，有什么用处，有什么特色和优点

一楼到十楼的每层电梯门口都放着一颗钻石，钻石大小不一。你乘坐电梯从一楼到十楼，每层楼电梯门都会打开一次，只能拿一次钻石。问怎么才能拿到最大的一颗？