🔮 :: Collision of Realms

📝 Rust Code

use nannou::prelude::*;

const NUM_BALLS: usize = 10_000;
const WINDOW_SIZE: f32 = 800.0;
const BALL_RADIUS: f32 = 1.0;
const GRAVITY: f32 = 0.005;
const LARGE_CIRCLE_RADIUS: f32 = 400.0;
const RESTITUTION: f32 = 0.95;
const MAX_BOUNCING_COUNT: u32 = 10;
const STOP_THRESHOLD: f32 = 0.1;

struct Ball {
    position: Vec2,
    velocity: Vec2,
    center: Vec2,
    gravity_direction: f32,
    bouncing_count: u32,
    stopped: bool,
}

struct Model {
    balls: Vec<Ball>,
}

fn main() {
    nannou::app(model).update(update).run();
}

fn model(app: &App) -> Model {
    app.new_window()
        .size(WINDOW_SIZE as u32, WINDOW_SIZE as u32)
        .view(view)
        .build()
        .unwrap();

    let circle_center_top = vec2(0.0, 400.0);
    let circle_center_bottom = vec2(0.0, -400.0);
    let mut balls = Vec::new();
    
    // 위쪽 원 중심에서 아래로 떨어지는 공들
    for _ in 0..(NUM_BALLS / 2) {
        let angle = random_range(0.0, PI);
        let speed = random_range(0.5, 1.0);
        balls.push(Ball {
            position: circle_center_top,
            velocity: vec2(angle.cos() * speed, -angle.sin() * speed),
            center: circle_center_top,
            gravity_direction: -1.0,
            bouncing_count: 0,
            stopped: false,
        });
    }
    
    // 아래쪽 원 중심에서 위로 올라가는 공들
    for _ in 0..(NUM_BALLS / 2) {
        let angle = random_range(0.0, PI);
        let speed = random_range(0.5, 1.0);
        balls.push(Ball {
            position: circle_center_bottom,
            velocity: vec2(angle.cos() * speed, angle.sin() * speed),
            center: circle_center_bottom,
            gravity_direction: 1.0,
            bouncing_count: 0,
            stopped: false,
        });
    }
    
    Model { balls }
}

fn update(_app: &App, model: &mut Model, _update: Update) {
    for ball in &mut model.balls {
        if ball.stopped {
            continue;
        }
        
        // 중력 적용 (위쪽은 아래로, 아래쪽은 위로)
        ball.velocity.y += GRAVITY * ball.gravity_direction;
        ball.position += ball.velocity;

        // 큰 원의 중심으로부터 거리 계산
        let distance_from_center = ball.position.distance(ball.center);
        let distance_diff = (distance_from_center - LARGE_CIRCLE_RADIUS).abs();
        
        // 큰 원의 반경 밖으로 나가면 충돌 처리
        if distance_from_center > LARGE_CIRCLE_RADIUS - BALL_RADIUS {
            ball.bouncing_count += 1;
            
            // 원의 표면으로 위치 보정
            let direction = (ball.position - ball.center).normalize();
            ball.position = ball.center + direction * (LARGE_CIRCLE_RADIUS - BALL_RADIUS);
            
            // 법선 벡터 (원의 중심에서 공으로 향하는 방향)
            let normal = direction;
            
            // 속도를 법선 방향과 접선 방향으로 분해
            let velocity_normal = ball.velocity.dot(normal);
            let velocity_tangent = ball.velocity - normal * velocity_normal;
            
            // 법선 방향 속도만 반전하고 반발계수 적용
            ball.velocity = velocity_tangent + normal * (-velocity_normal * RESTITUTION);
            
            // 정지 조건 확인
            if ball.bouncing_count >= MAX_BOUNCING_COUNT || distance_diff < STOP_THRESHOLD {
                ball.stopped = true;
                ball.velocity = vec2(0.0, 0.0);
            }
        }
    }
}

fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();

    let frame_no = frame.nth();
    if frame_no == 0 {
        draw.background().color(hsla(0.0, 0.0, 0.01, 1.0));
    } else {
        draw.rect()
        .w_h(WINDOW_SIZE, WINDOW_SIZE)
        .color(hsla(0.0, 0.0, 0.01, 0.1));
    }    
    
    // 작은 공들 그리기 (정지된 공은 그리지 않음)
    for ball in &model.balls {
        if !ball.stopped {
            draw.ellipse()
                .xy(ball.position)
                .radius(BALL_RADIUS)
                .color(rgba(1.0, 1.0, 1.0, 0.8));
        }
    }      

    draw.to_frame(app, &frame).unwrap();
}