Мы создадим трехмерную версию игры «Жизнь» Конвея, где клетки эволюционируют в 3D-пространстве!

3D Game of Life:

cpp

#define GRID_SIZE 8
#define CELL_COUNT (GRID_SIZE * GRID_SIZE * GRID_SIZE)

// Состояния клеток (0=мертва, 1=жива, 2=делится)
uint8_t grid[GRID_SIZE][GRID_SIZE][GRID_SIZE];
uint8_t newGrid[GRID_SIZE][GRID_SIZE][GRID_SIZE];

// Жизненный цикл клетки
uint8_t cellCycle[3] = {1, 2, 0};  // Жива -> Делится -> Мертва

// Подсчет соседей в 3D (26 соседей)
uint8_t countNeighbors3D(uint8_t x, uint8_t y, uint8_t z) {
    uint8_t count = 0;
    for (int8_t dx = -1; dx <= 1; dx++) {
        for (int8_t dy = -1; dy <= 1; dy++) {
            for (int8_t dz = -1; dz <= 1; dz++) {
                if (dx == 0 && dy == 0 && dz == 0) continue;
                uint8_t nx = (x + dx + GRID_SIZE) % GRID_SIZE;
                uint8_t ny = (y + dy + GRID_SIZE) % GRID_SIZE;
                uint8_t nz = (z + dz + GRID_SIZE) % GRID_SIZE;
                if (grid[nx][ny][nz] > 0) count++;
            }
        }
    }
    return count;
}

// Эволюция (3D правила)
void evolve3D() {
    memset(newGrid, 0, sizeof(newGrid));
    
    for (uint8_t x = 0; x < GRID_SIZE; x++) {
        for (uint8_t y = 0; y < GRID_SIZE; y++) {
            for (uint8_t z = 0; z < GRID_SIZE; z++) {
                uint8_t neighbors = countNeighbors3D(x, y, z);
                
                if (grid[x][y][z] > 0) {
                    // Живая клетка
                    if (neighbors < 2 || neighbors > 6) {
                        // Смерть
                        newGrid[x][y][z] = 0;
                    } else if (neighbors >= 4 && neighbors <= 5) {
                        // Деление
                        newGrid[x][y][z] = 2;
                    } else {
                        // Остается живой
                        newGrid[x][y][z] = 1;
                    }
                } else {
                    // Мертвая клетка - рождение
                    if (neighbors == 3) {
                        newGrid[x][y][z] = 1;
                    }
                }
            }
        }
    }
    
    // Обновляем сеть и жизненные циклы
    memcpy(grid, newGrid, sizeof(grid));
    
    // Старение клеток
    for (uint8_t x = 0; x < GRID_SIZE; x++) {
        for (uint8_t y = 0; y < GRID_SIZE; y++) {
            for (uint8_t z = 0; z < GRID_SIZE; z++) {
                if (grid[x][y][z] > 0) {
                    grid[x][y][z] = cellCycle[grid[x][y][z] % 3];
                }
            }
        }
    }
}

// Инициализация случайной жизни
void initLife() {
    randomSeed(analogRead(A0));
    for (uint8_t x = 0; x < GRID_SIZE; x++) {
        for (uint8_t y = 0; y < GRID_SIZE; y++) {
            for (uint8_t z = 0; z < GRID_SIZE; z++) {
                grid[x][y][z] = (random(100) < 30) ? 1 : 0;
            }
        }
    }
}

// Рендеринг 3D жизни на OLED (проекция)
void renderLife3D() {
    clearScreen();
    
    // Для каждого слоя Z отображаем проекцию
    for (uint8_t z = 0; z < GRID_SIZE; z++) {
        uint8_t offsetY = z * 2;
        for (uint8_t x = 0; x < GRID_SIZE; x++) {
            for (uint8_t y = 0; y < GRID_SIZE; y++) {
                if (grid[x][y][z] > 0) {
                    uint8_t screenX = x * 4 + z * 2;
                    uint8_t screenY = y * 4 + offsetY;
                    if (screenX < 64 && screenY < 64) {
                        drawPixel(screenX, screenY, 1);
                    }
                }
            }
        }
    }
    
    updateDisplay();
}

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

void loop() {
    // Эволюционируем 10 поколений за раз
    for (uint8_t gen = 0; gen < 10; gen++) {
        evolve3D();
    }
    renderLife3D();
    delay(100);
}