Мы создадим систему, которая симулирует параллельные вселенные, каждая со своими физическими законами, и позволяет переключаться между ними!

Симулятор мультивселенной:

cpp

#define UNIVERSE_COUNT 4

// Параметры вселенной
struct Universe {
    uint8_t id;
    uint8_t gravityConstant;
    uint8_t speedOfLight;
    uint8_t particleCount;
    uint8_t entropy;
    uint8_t lifeProbability;
};

Universe universes[UNIVERSE_COUNT];
uint8_t currentUniverse = 0;

// Состояние вселенной (16x16 клеток)
uint8_t universeState[UNIVERSE_COUNT][16][16];

// Инициализация вселенных
void initUniverses() {
    // Вселенная 1: Наша (физика как в реальности)
    universes[0].id = 0;
    universes[0].gravityConstant = 100;
    universes[0].speedOfLight = 10;
    universes[0].particleCount = 50;
    universes[0].entropy = 100;
    universes[0].lifeProbability = 30;
    
    // Вселенная 2: Гравитация в 2 раза сильнее
    universes[1].id = 1;
    universes[1].gravityConstant = 200;
    universes[1].speedOfLight = 8;
    universes[1].particleCount = 30;
    universes[1].entropy = 150;
    universes[1].lifeProbability = 15;
    
    // Вселенная 3: Слабая гравитация, много энергии
    universes[2].id = 2;
    universes[2].gravityConstant = 30;
    universes[2].speedOfLight = 15;
    universes[2].particleCount = 100;
    universes[2].entropy = 50;
    universes[2].lifeProbability = 60;
    
    // Вселенная 4: Хаотичная (энтропия максимальна)
    universes[3].id = 3;
    universes[3].gravityConstant = 150;
    universes[3].speedOfLight = 5;
    universes[3].particleCount = 200;
    universes[3].entropy = 255;
    universes[3].lifeProbability = 5;
    
    // Инициализируем состояния
    for (uint8_t u = 0; u < UNIVERSE_COUNT; u++) {
        for (uint8_t x = 0; x < 16; x++) {
            for (uint8_t y = 0; y < 16; y++) {
                universeState[u][x][y] = random(universes[u].entropy / 100 + 1);
            }
        }
    }
}

// Эволюция вселенной (свои законы для каждой)
void evolveUniverse(uint8_t universeId) {
    Universe* u = &universes[universeId];
    
    // Копируем состояние
    uint8_t newState[16][16];
    memcpy(newState, universeState[universeId], sizeof(newState));
    
    // Применяем законы физики
    for (uint8_t x = 0; x < 16; x++) {
        for (uint8_t y = 0; y < 16; y++) {
            // Соседи
            uint8_t neighbors = 0;
            for (int8_t dx = -1; dx <= 1; dx++) {
                for (int8_t dy = -1; dy <= 1; dy++) {
                    if (dx == 0 && dy == 0) continue;
                    uint8_t nx = (x + dx + 16) % 16;
                    uint8_t ny = (y + dy + 16) % 16;
                    neighbors += (universeState[universeId][nx][ny] > 0);
                }
            }
            
            // Правила эволюции (зависят от параметров вселенной)
            if (universeState[universeId][x][y] > 0) {
                // Живая клетка
                if (neighbors < 2 || neighbors > u->particleCount / 10) {
                    newState[x][y] = 0;  // Смерть
                } else {
                    newState[x][y] = min(255, universeState[universeId][x][y] + 1);
                }
            } else {
                // Рождение
                if (neighbors == 3 && random(100) < u->lifeProbability) {
                    newState[x][y] = 1;
                }
            }
        }
    }
    
    // Обновляем состояние
    memcpy(universeState[universeId], newState, sizeof(newState));
}

// Переключение между вселенными
void switchUniverse(uint8_t newUniverse) {
    if (newUniverse < UNIVERSE_COUNT) {
        currentUniverse = newUniverse;
        Serial.print("🌍 Переключено на Вселенную ");
        Serial.println(currentUniverse);
        Serial.print("  Гравитация: ");
        Serial.println(universes[currentUniverse].gravityConstant);
        Serial.print("  Скорость света: ");
        Serial.println(universes[currentUniverse].speedOfLight);
    }
}

// Визуализация текущей вселенной
void renderUniverse() {
    clearScreen();
    
    for (uint8_t x = 0; x < 16; x++) {
        for (uint8_t y = 0; y < 16; y++) {
            uint8_t val = universeState[currentUniverse][x][y];
            if (val > 0) {
                // Масштабируем для отображения
                uint8_t brightness = val * 2;
                drawPixel(x * 4 + 2, y * 4 + 2, brightness > 128);
            }
        }
    }
    
    // Информация о вселенной
    // ...
    
    updateDisplay();
}

void setup() {
    initOLED();
    initUniverses();
    Serial.begin(115200);
    Serial.println("🌍 МУЛЬТИВСЕЛЕННАЯ АКТИВИРОВАНА");
}

void loop() {
    // Эволюционируем все вселенные
    for (uint8_t u = 0; u < UNIVERSE_COUNT; u++) {
        for (uint8_t step = 0; step < 5; step++) {
            evolveUniverse(u);
        }
    }
    
    // Переключаем вселенные автоматически
    static uint32_t lastSwitch = 0;
    if (millis() - lastSwitch > 5000) {
        switchUniverse((currentUniverse + 1) % UNIVERSE_COUNT);
        lastSwitch = millis();
    }
    
    // Рендеринг
    renderUniverse();
    delay(100);
}