🔮 :: Sperm Racing

📝 Rust Code

use nannou::prelude::*;
use nannou::noise::{NoiseFn, Perlin};
use rand::Rng;

struct Sperm {
    head: Point2,
    velocity: Vec2,
    speed: f32,
    phase: f32,
    amp: f32,
    swimming_phase: f32,  // 헤엄치는 리듬
    energy: f32,          // 에너지 레벨 (시간에 따라 변함)
    head_bob_phase: f32,  // 머리 상하 진동용 위상
    head_bob_freq: f32,   // 머리 진동 주파수
}

struct Model {
    sperms: Vec<Sperm>,
    time: f32,
    noise: Perlin,
}

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

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

    Model {
        sperms: Vec::new(),
        time: 0.0,
        noise: Perlin::new(),
    }
}

fn update(app: &App, model: &mut Model, update: Update) {
    let dt = update.since_last.as_secs_f32();
    model.time += dt;

    let win = app.window_rect();

    // 최대 1000마리 유지
    while model.sperms.len() < 1500 {
        let mut rng = rand::thread_rng();
        let y = rng.gen_range((win.bottom() + 20.0)..(win.top() - 20.0));
        let speed = rng.gen_range(57.0..105.0);  // 속도 범위 조정
        let phase = rng.gen_range(0.0..TAU);
        let amp = rng.gen_range(0.8..1.4);
        let swimming_phase = rng.gen_range(0.0..TAU);
        let head_bob_phase = rng.gen_range(0.0..TAU);
        let head_bob_freq = rng.gen_range(2.5..4.5);  // 개체별 다른 진동 주파수
        
        model.sperms.push(Sperm {
            head: pt2(win.right() + 60.0, y),
            velocity: vec2(-1.0, 0.0),
            speed,
            phase,
            amp,
            swimming_phase,
            energy: rng.gen_range(0.7..1.0),
            head_bob_phase,
            head_bob_freq,
        });
    }

    // 정자 움직임 업데이트
    for s in model.sperms.iter_mut() {
        // 헤엄치는 리듬 업데이트 (개체별로 다른 주기)
        s.swimming_phase += dt * 6.0 * s.amp;  // 속도 조금 낮춤
        s.head_bob_phase += dt * s.head_bob_freq;
        
        // 에너지 변화 (시간에 따른 피로감 시뮬레이션)
        s.energy = (s.energy - dt * 0.05).max(0.3);
        
        // 기본 전진 방향에 수직/수평 진동 추가
        let lateral_oscillation = (s.swimming_phase * 0.8).sin() * 6.0 * s.amp * s.energy;  // 진폭 감소
        let forward_oscillation = (s.swimming_phase * 0.5).cos() * 2.0 * s.amp;  // 진폭 감소
        
        // Perlin 노이즈로 불규칙한 방향 변화 (더 부드럽게)
        let noise_x = model.noise.get([s.phase as f64 * 0.2, model.time as f64 * 0.4]) as f32;
        let noise_y = model.noise.get([s.phase as f64 * 0.2 + 100.0, model.time as f64 * 0.4]) as f32;
        
        // 머리 상하 진동 (각자 다른 주파수와 위상)
        let head_bob = (s.head_bob_phase).sin() * 4.0 * s.energy;
        let head_bob_noise = model.noise.get([s.phase as f64 * 0.15, model.time as f64 * 0.6]) as f32 * 2.5;
        
        // 방향 벡터 계산
        s.velocity = vec2(
            -1.0 + forward_oscillation * 0.08 + noise_x * 0.1,
            lateral_oscillation * 0.015 + noise_y * 0.08
        ).normalize();
        
        // 속도에 에너지와 헤엄치는 리듬 반영 (더 부드럽게)
        let rhythm_variation = (s.swimming_phase * 1.2).sin() * 0.15;
        let current_speed = s.speed * s.energy * (1.0 + rhythm_variation);
        
        // 기본 이동
        s.head += s.velocity * current_speed * dt;
        
        // 머리에 상하 진동 추가 (기본 이동과 별개)
        s.head.y += (head_bob + head_bob_noise) * dt * 25.0;
    }

    // 화면을 벗어난 정자 제거
    let tail_len = 80.0;  // 꼬리 길이 증가으로 감소
    model.sperms.retain(|s| s.head.x > win.left() - tail_len - 10.0);
}

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

    let tail_len = 80.0;  // 꼬리 길이 증가
    let segments = 25;    // 세그먼트 수 증가로 더 부드럽게
    let base_amplitude = 8.0;  // 진폭 감소
    let wavelength = 0.6;  // 파장 증가로 더 부드러운 곡선
    let wave_speed = 4.5;  // 파형 속도 감소

    for s in model.sperms.iter() {
        let head = s.head;

        let dir = if s.velocity.length() > 0.0 {
            s.velocity.normalize()
        } else {
            vec2(-1.0, 0.0)
        };

        let perp = vec2(-dir.y, dir.x);

        // 꼬리 점들 계산
        let mut points: Vec<Point2> = Vec::with_capacity(segments + 1);
        for i in 0..=segments {
            let t = i as f32 / segments as f32;
            let base = head + dir * (-t * tail_len);

            // 더 부드러운 파형 조합
            let primary_wave = (model.time * wave_speed + s.phase + t / wavelength).sin();
            let secondary_wave = (model.time * wave_speed * 0.6 + s.phase * 1.3 + t / (wavelength * 1.2)).sin() * 0.3;
            
            // 헤엄치는 리듬과 연동 (더 부드럽게)
            let rhythm_factor = (s.swimming_phase * 0.7 + t * 1.5).sin() * 0.2;
            
            // 더 부드러운 노이즈
            let noise_val = model.noise.get([
                (s.phase as f64) * 0.25,
                (model.time as f64) * 0.8 + (t as f64) * 2.0,
            ]) as f32;

            // 꼬리 끝으로 갈수록 부드럽게 증가 (제곱 함수 사용)
            let intensity = (t * t * 1.5).min(1.0);
            
            let local_amp = base_amplitude * s.amp * s.energy;
            let y_offset = (primary_wave * 0.6 + secondary_wave + rhythm_factor + noise_val * 0.4) 
                         * local_amp * intensity;

            let offset = perp * y_offset;
            points.push(base + offset);
        }

        // 머리 크기 2.5로 설정
        draw.ellipse().xy(head).radius(2.5).color(WHITE);

        // 꼬리를 세그먼트별로 불투명도 변화와 함께 그리기
        for i in 0..(points.len() - 1) {
            let t = i as f32 / (points.len() - 1) as f32;
            
            // 머리에서 꼬리로 갈수록 불투명도 감소 (1.0 -> 0.1)
            let alpha = 1.0 - (t * 0.9);
            
            // 두께도 점진적으로 감소
            let thickness = 2.0 * (1.0 - t * 0.6);
            
            draw.line()
                .start(points[i])
                .end(points[i + 1])
                .weight(thickness.max(0.3))
                .color(rgba(1.0, 1.0, 1.0, alpha));
        }
    }

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