Мы создадим систему, которая искривляет пространство-время на LED-матрице, симулируя гравитационные линзы и искривление света!

Гравитационная линза на LED-матрице:

cpp

#include <avr/pgmspace.h>

#define GRID_SIZE 16
#define LIGHT_RAYS 32

// 2D пространство-время (искривление)
int8_t spacetime[GRID_SIZE][GRID_SIZE];

// Масса (гравитационный источник)
int8_t massX, massY;
uint8_t massStrength;

// Лучи света (фотоны)
struct LightRay {
    int8_t x, y;
    int8_t dx, dy;
    uint8_t intensity;
};

LightRay rays[LIGHT_RAYS];

// Искривление пространства-времени
void curveSpacetime() {
    // Метрика искривления: ds² = -dt² + (1 + 2Φ)dr²
    for (int8_t x = 0; x < GRID_SIZE; x++) {
        for (int8_t y = 0; y < GRID_SIZE; y++) {
            int8_t dx = x - massX;
            int8_t dy = y - massY;
            int16_t dist2 = dx * dx + dy * dy;
            if (dist2 < 1) dist2 = 1;
            
            // Гравитационный потенциал Φ = -GM/r
            int16_t phi = (-massStrength * 100) / dist2;
            spacetime[x][y] = phi / 100;
        }
    }
}

// Трассировка света (геодезические)
void traceLightRays() {
    for (uint8_t i = 0; i < LIGHT_RAYS; i++) {
        LightRay* ray = &rays[i];
        
        // Сила искривления в текущей точке
        int8_t curvature = spacetime[ray->x][ray->y];
        
        // Изменение направления (эффект гравитационной линзы)
        int8_t fx = (massX - ray->x) * curvature / 8;
        int8_t fy = (massY - ray->y) * curvature / 8;
        
        ray->dx += fx;
        ray->dy += fy;
        
        // Нормализация скорости света
        int16_t speed2 = ray->dx * ray->dx + ray->dy * ray->dy;
        if (speed2 > 0) {
            int16_t speed = sqrt(speed2);
            int16_t c = 10;  // Скорость света
            ray->dx = (ray->dx * c) / speed;
            ray->dy = (ray->dy * c) / speed;
        }
        
        // Перемещение
        ray->x += ray->dx;
        ray->y += ray->dy;
        
        // Интенсивность (красное смещение)
        if (abs(ray->x - massX) < 2 && abs(ray->y - massY) < 2) {
            ray->intensity = max(0, ray->intensity - 10);  // Поглощение
        }
    }
}

// Визуализация гравитационной линзы
void renderGravitationalLens() {
    clearScreen();
    
    // Рисуем искривленное пространство-время
    for (int8_t x = 0; x < GRID_SIZE; x++) {
        for (int8_t y = 0; y < GRID_SIZE; y++) {
            uint8_t brightness = 64 + spacetime[x][y] * 4;
            if (brightness > 255) brightness = 255;
            drawPixel(x, y, brightness > 128);
        }
    }
    
    // Рисуем лучи света
    for (uint8_t i = 0; i < LIGHT_RAYS; i++) {
        LightRay* ray = &rays[i];
        if (ray->x >= 0 && ray->x < GRID_SIZE && 
            ray->y >= 0 && ray->y < GRID_SIZE) {
            drawPixel(ray->x, ray->y, 1);
        }
    }
    
    // Рисуем массу (черная дыра)
    drawPixel(massX, massY, 0);
    drawPixel(massX + 1, massY, 0);
    drawPixel(massX - 1, massY, 0);
    drawPixel(massX, massY + 1, 0);
    drawPixel(massX, massY - 1, 0);
    
    updateDisplay();
}

// Инициализация
void initGravitySimulation() {
    // Создаем искривление
    massX = GRID_SIZE / 2;
    massY = GRID_SIZE / 2;
    massStrength = 100;
    curveSpacetime();
    
    // Инициализируем лучи света
    for (uint8_t i = 0; i < LIGHT_RAYS; i++) {
        rays[i].x = random(GRID_SIZE);
        rays[i].y = 0;
        rays[i].dx = random(-2, 3);
        rays[i].dy = random(1, 3);
        rays[i].intensity = 255;
    }
}

void setup() {
    initOLED();
    initGravitySimulation();
    Serial.println("🌌 ИСКУССТВЕННАЯ ГРАВИТАЦИЯ АКТИВИРОВАНА");
}

void loop() {
    // Обновляем гравитацию (движение массы)
    massX = GRID_SIZE / 2 + sin(millis() / 1000.0) * 3;
    massY = GRID_SIZE / 2 + cos(millis() / 1500.0) * 3;
    curveSpacetime();
    
    // Трассируем лучи света
    for (uint8_t step = 0; step < 5; step++) {
        traceLightRays();
    }
    
    // Визуализация
    renderGravitationalLens();
    delay(50);
}