Мы создадим реалистичную симуляцию черной дыры с учетом общей теории относительности и гравитационного замедления времени!

Модель черной дыры Шварцшильда:

cpp

#include <avr/random.h>
#include <avr/pgmspace.h>

#define PARTICLE_COUNT 32
#define GRAVITY_CONST 1000
#define LIGHT_SPEED 300000  // В пикселях/сек

// Структура частицы (звезды, планеты, фотоны)
struct Particle {
    int16_t x, y;
    int16_t vx, vy;
    uint16_t mass;
    uint8_t type;  // 0=звезда, 1=фотон, 2=планета
    uint8_t timeDilation;  // Замедление времени (0-255)
};

Particle particles[PARTICLE_COUNT];
int16_t blackHoleX, blackHoleY;
uint16_t blackHoleMass = 10000;

// Метрика Шварцшильда (радиус Шварцшильда)
int16_t schwarzschildRadius() {
    return (2 * GRAVITY_CONST * blackHoleMass) / (LIGHT_SPEED * LIGHT_SPEED);
}

// Гравитационное замедление времени
uint8_t timeDilation(int16_t x, int16_t y) {
    int16_t dx = x - blackHoleX;
    int16_t dy = y - blackHoleY;
    int32_t dist2 = dx * dx + dy * dy;
    int16_t dist = sqrt(dist2);
    
    if (dist < 1) dist = 1;
    int16_t rs = schwarzschildRadius();
    
    // t = t0 / sqrt(1 - rs/r)
    int32_t factor = 1000 - (rs * 1000) / dist;
    if (factor < 0) factor = 0;
    uint8_t dilation = 255 - (factor * 255) / 1000;
    return dilation;
}

// Геодезическая линия (движение в искривленном пространстве-времени)
void moveParticle(uint8_t idx) {
    Particle* p = &particles[idx];
    
    // Время замедляется
    p->timeDilation = timeDilation(p->x, p->y);
    
    // Гравитационное ускорение (закон Ньютона + релятивистские поправки)
    int16_t dx = blackHoleX - p->x;
    int16_t dy = blackHoleY - p->y;
    int32_t dist2 = dx * dx + dy * dy;
    if (dist2 < 1) dist2 = 1;
    int32_t invDist2 = (GRAVITY_CONST * blackHoleMass) / dist2;
    
    // Сила гравитации с учетом замедления времени
    int16_t gravityFactor = 1000 - (p->timeDilation * 500) / 255;
    p->vx += (dx * invDist2 * gravityFactor) / 10000;
    p->vy += (dy * invDist2 * gravityFactor) / 10000;
    
    // Ограничение скорости (скорость света)
    int32_t speed2 = p->vx * p->vx + p->vy * p->vy;
    if (speed2 > LIGHT_SPEED * LIGHT_SPEED) {
        int32_t speed = sqrt(speed2);
        p->vx = (p->vx * LIGHT_SPEED) / speed;
        p->vy = (p->vy * LIGHT_SPEED) / speed;
    }
    
    // Перемещение с учетом замедления времени
    uint8_t timeStep = 255 - p->timeDilation;
    p->x += (p->vx * timeStep) / 255;
    p->y += (p->vy * timeStep) / 255;
}

// Гравитационное линзирование (для фотонов)
void gravitationalLensing(uint8_t idx) {
    Particle* p = &particles[idx];
    if (p->type != 1) return;  // Только для фотонов
    
    int16_t dx = blackHoleX - p->x;
    int16_t dy = blackHoleY - p->y;
    int32_t dist2 = dx * dx + dy * dy;
    int16_t dist = sqrt(dist2);
    int16_t rs = schwarzschildRadius();
    
    // Угол отклонения: α = 4GM/(c^2 * r)
    if (dist > 0 && dist < rs * 10) {
        int16_t angle = (4 * GRAVITY_CONST * blackHoleMass) / (LIGHT_SPEED * LIGHT_SPEED * dist);
        // Поворачиваем вектор скорости
        int16_t vx = p->vx;
        int16_t vy = p->vy;
        p->vx = vx * cos(angle) - vy * sin(angle);
        p->vy = vx * sin(angle) + vy * cos(angle);
    }
}

// Аккреционный диск (свечение материи)
void renderAccretionDisk() {
    for (int16_t r = schwarzschildRadius() * 3; r < schwarzschildRadius() * 8; r++) {
        for (uint16_t angle = 0; angle < 360; angle += 10) {
            int16_t x = blackHoleX + r * cos(angle);
            int16_t y = blackHoleY + r * sin(angle);
            
            // Интенсивность зависит от расстояния
            uint8_t intensity = 255 - (r * 255) / (schwarzschildRadius() * 8);
            if (r % 20 < 10) intensity /= 2;  // Кольца
            
            // Визуализация на OLED
            drawPixel(x / 4 + 32, y / 4 + 32, intensity > 100);
        }
    }
}

// Горизонт событий (черный круг)
void renderEventHorizon() {
    int16_t rs = schwarzschildRadius();
    for (int16_t r = 0; r < rs / 4; r++) {
        for (uint16_t angle = 0; angle < 360; angle += 5) {
            int16_t x = blackHoleX + r * cos(angle);
            int16_t y = blackHoleY + r * sin(angle);
            drawPixel(x / 4 + 32, y / 4 + 32, 1);  // Черный (инвертировано)
        }
    }
}

// Инициализация черной дыры
void initBlackHole() {
    blackHoleX = 0;
    blackHoleY = 0;
    
    // Звезды вокруг черной дыры
    for (uint8_t i = 0; i < PARTICLE_COUNT; i++) {
        particles[i].type = 0;
        uint16_t radius = schwarzschildRadius() * (10 + random(0, 40));
        uint16_t angle = random(0, 360);
        particles[i].x = radius * cos(angle);
        particles[i].y = radius * sin(angle);
        particles[i].vx = -radius * sin(angle) * 0.1;
        particles[i].vy = radius * cos(angle) * 0.1;
        particles[i].mass = random(100, 1000);
        particles[i].timeDilation = 0;
    }
    
    // Фотоны (световые лучи)
    for (uint8_t i = 0; i < 8; i++) {
        particles[PARTICLE_COUNT - 8 + i].type = 1;
        uint16_t angle = random(0, 360);
        particles[PARTICLE_COUNT - 8 + i].x = schwarzschildRadius() * 20 * cos(angle);
        particles[PARTICLE_COUNT - 8 + i].y = schwarzschildRadius() * 20 * sin(angle);
        particles[PARTICLE_COUNT - 8 + i].vx = -LIGHT_SPEED * cos(angle) / 1000;
        particles[PARTICLE_COUNT - 8 + i].vy = -LIGHT_SPEED * sin(angle) / 1000;
        particles[PARTICLE_COUNT - 8 + i].mass = 0;
        particles[PARTICLE_COUNT - 8 + i].timeDilation = 0;
    }
}

void setup() {
    initOLED();
    initBlackHole();
}

void loop() {
    // Симулируем 10 шагов
    for (uint8_t step = 0; step < 10; step++) {
        for (uint8_t i = 0; i < PARTICLE_COUNT; i++) {
            if (particles[i].type == 1) {
                gravitationalLensing(i);
            }
            moveParticle(i);
        }
    }
    
    // Рендеринг
    clearScreen();
    renderAccretionDisk();
    renderEventHorizon();
    
    // Рисуем частицы
    for (uint8_t i = 0; i < PARTICLE_COUNT; i++) {
        uint8_t screenX = 32 + particles[i].x / 4;
        uint8_t screenY = 32 + particles[i].y / 4;
        if (screenX < 64 && screenY < 64) {
            uint8_t color = (particles[i].type == 1) ? 1 : 0;
            drawPixel(screenX, screenY, color);
        }
    }
    
    updateDisplay();
    delay(50);
}