birbiriyle etkileşen hücrelere dair 3 kural, süreç incelenmediği sürece öngörülemez ve tahmin edilemez neticeler doğuruyor: #include <GLFW/glfw3.h> // GLFW kütüphanesini içe aktarır; pencere oluşturma ve OpenGL ile çizim için kullanılır. #include <vector> // Dinamik diziler ve iki boyutlu vektör yapısı için vektör kütüphanesi. #include <ctime> // Rastgele sayı üreteci için zaman kütüphanesi. #include <cstdlib> // Rastgele sayı üreteci için C standardında kütüphane.
const int GENISLIK = 1920; // Pencere genişliği piksel cinsinden
const int YUKSEKLIK = 1080; // Pencere yüksekliği piksel cinsinden
const int HUCRESAYISI = 4; // Her bir hücrenin genişliği ve yüksekliği piksel cinsinden
const int IZGARA_GENISLIK = GENISLIK / HUCRESAYISI; // Hücre matrisinin yatayda hücre sayısı
const int IZGARA_YUKSEKLIK = YUKSEKLIK / HUCRESAYISI; // Hücre matrisinin dikeyde hücre sayısı
// Hücrelerin durumunu tutan iki boyutlu matris; 2: genişleyen hücre, 1: hücre dolu, 0: hücre boş
std::vector<std::vector<int>> izgara(IZGARA_YUKSEKLIK, std::vector<int>(IZGARA_GENISLIK, 0));
// Bir sonraki durumları tutmak için yedek matris
std::vector<std::vector<int>> sonrakiIzgara(IZGARA_YUKSEKLIK, std::vector<int>(IZGARA_GENISLIK, 0));
// **Yaşam Oyunu Kuralları**:
// 1. Her dolu hücre 2 veya 3 komşuya sahipse yaşamaya devam eder, aksi halde ölür.
// 2. Boş hücreler tam 3 dolu komşuya sahipse canlanır.
void izgaraBaslat() { // Hücre matrisini başlatır
srand(static_cast<unsigned>(time(0))); // Rastgele başlangıç için tohum oluşturur.
for (int y = 0; y < IZGARA_YUKSEKLIK; ++y) { // Her hücre için
for (int x = 0; x < IZGARA_GENISLIK; ++x) {
izgara[y][x] = rand() % 2; // Hücreyi rastgele olarak dolu (1) veya boş (0) yapar.
}
}
}
int komsuSay(int y, int x) { // Hücrenin komşularını say
int sayac = 0; // Komşu hücre sayacını sıfırla.
for (int dy = -1; dy <= 1; ++dy) { // -1, 0, 1: komşu hücreler için dikey kayma
for (int dx = -1; dx <= 1; ++dx) { // -1, 0, 1: komşu hücreler için yatay kayma
if (dy == 0 && dx == 0) continue; // Kendisi değil, sadece komşuları kontrol et.
int ny = (y + dy + IZGARA_YUKSEKLIK) % IZGARA_YUKSEKLIK; // Dikeyde çevrilebilir koordinat
int nx = (x + dx + IZGARA_GENISLIK) % IZGARA_GENISLIK; // Yatayda çevrilebilir koordinat
sayac += izgara[ny][nx]; // Eğer komşu hücre dolu ise sayacı artır.
}
}
return sayac; // Bulunan komşu hücrelerin toplam sayısını döndür.
}
void izgaraGuncelle() { // Hücrelerin durumlarını günceller
for (int y = 0; y < IZGARA_YUKSEKLIK; ++y) { // Her hücreyi güncelle
for (int x = 0; x < IZGARA_GENISLIK; ++x) {
int komsular = komsuSay(y, x); // Mevcut hücrenin komşu sayısını al
if (izgara[y][x] == 1) { // Hücre dolu ise
sonrakiIzgara[y][x] = (komsular == 2 || komsular == 3) ? 1 : 0; // 2 veya 3 komşu ile hayatta kalır.
} else if (izgara[y][x] == 2) { // Genişleyen hücre durumu
sonrakiIzgara[y][x] = (komsular >= 1) ? 2 : 0; // Komşuları varsa genişlemeye devam et.
} else { // Hücre boş ise
sonrakiIzgara[y][x] = (komsular == 3) ? 1 : 0; // Boş hücre, 3 komşu varsa doğar.
}
}
}
izgara.swap(sonrakiIzgara); // Eski durumu yeni durumla değiştir.
}
// Hücreleri çizer.
for (int y = 0; y < IZGARA_YUKSEKLIK; ++y) {
for (int x = 0; x < IZGARA_GENISLIK; ++x) {
if (izgara[y][x] == 1) { // Hücre dolu ise
glColor3f(0.0f, 1.0f, 0.0f); // Yeşil rengi ayarla.
} else if (izgara[y][x] == 2) { // Genişleyen hücre ise
glColor3f(0.0f, 1.0f, 0.5f); // Yeşil tonunda bir renk
} else {
glColor3f(0.0f, 0.0f, 0.0f); // Boş hücreler için siyah arka plan
}
glBegin(GL_QUADS); // Her hücreyi kare olarak çiz.
glVertex2f(x * HUCRESAYISI, y * HUCRESAYISI);
glVertex2f((x + 1) * HUCRESAYISI - 1, y * HUCRESAYISI);
glVertex2f((x + 1) * HUCRESAYISI - 1, (y + 1) * HUCRESAYISI - 1);
glVertex2f(x * HUCRESAYISI, (y + 1) * HUCRESAYISI - 1);
glEnd();
}
}
// Izgara çizgilerini çizer.
glColor3f(1.0f, 0.0f, 0.0f); // Izgara için kırmızı çizgi
glLineWidth(1.0f);
glBegin(GL_LINES);
for (int x = 0; x <= GENISLIK; x += HUCRESAYISI) {
glVertex2f(x, 0); glVertex2f(x, YUKSEKLIK); // Dikey çizgiler
}
for (int y = 0; y <= YUKSEKLIK; y += HUCRESAYISI) {
glVertex2f(0, y); glVertex2f(GENISLIK, y); // Yatay çizgiler
}
glEnd();
}
int main() { // Programın ana fonksiyonu
if (!glfwInit()) { // GLFW başlat.
return -1;
}
while (!glfwWindowShouldClose(pencere)) { // Pencere açıkken
izgaraCiz(); // Çizimi güncelle.
izgaraGuncelle(); // Oyun kurallarına göre hücre durumlarını güncelle.
glfwSwapBuffers(pencere); // Çizimi pencereye uygula.
glfwPollEvents(); // Olayları kontrol et.
}
biliyor musunuz aslında düzen için trafik ışıklarına gerek bile yok. hareket halindeki her aracın uymaya çalıştığı basit bir iki kural olsun kafi.
kural 1, yakın mesafede araç gördün mü yavaşla, yol boşken hızlan.
bu basit kurala göre hareket eden trafik, hiçbir trafik ışığı olmamasına rağmen kendi içinde inanılmaz karmaşık bir düzen geliştirebiliyor! https://www.youtube.com/watch?v=7aSkJCUDAes
3 şeritli bir yolda en sağ şerit sağa dönmek içindir. Orada kocaman sağa dönüş işareti vardır. En sağ şerit sürüş güvenliği gereği yoldan düz çizgi ile ayrılır ki kimse sapağa belli bir mesafe kala aniden şerit değiştirip kazaya sebep olmasın.
Ancak zannımca tam o an anası iğfal edilmekte olan bir sürücü biraz da buna mani olmak için bu salaklar en sağ şeritten niye gitmiyolar en sağ boş iiii mallara bağele diyerek en sağ şeride kayıp uzar. Sağ şeridin anayoldan ayrıldığını görünce piiii ananske diyerek kendini bir soldaki şeride atmaya çalışır. Genelde solundaki şerit dolu olduğundan kurtaramaz ve anayolla sapağı birbirinden ayıran bariyere girer.
Buradan bu vesileyle doğal seleksiyona katkıda bulunan karayolları genel müdürlüğüne şükranlarımı sunarım, sağolsun, varolsunlar.
#include <GLFW/glfw3.h> // GLFW kütüphanesini içe aktarır; pencere oluşturma ve OpenGL ile çizim için kullanılır. #include <vector> // Dinamik diziler ve iki boyutlu vektör yapısı için vektör kütüphanesi. #include <ctime> // Rastgele sayı üreteci için zaman kütüphanesi. #include <cstdlib> // Rastgele sayı üreteci için C standardında kütüphane.
const int WIDTH = 1920; // Pencere genişliği piksel cinsinden
const int HEIGHT = 1080; // Pencere yüksekliği piksel cinsinden
const int CELL_SIZE = 4; // Her bir hücrenin genişliği ve yüksekliği piksel cinsinden
const int GRID_WIDTH = WIDTH / CELL_SIZE; // Hücre matrisinin yatayda hücre sayısı
const int GRID_HEIGHT = HEIGHT / CELL_SIZE; // Hücre matrisinin dikeyde hücre sayısı
// Hücrelerin durumunu tutan iki boyutlu matris; 2: genişleyen hücre, 1: hücre dolu, 0: hücre boş
std::vector<std::vector<int>> grid(GRID_HEIGHT, std::vector<int>(GRID_WIDTH, 0));
// Bir sonraki durumları tutmak için yedek matris
std::vector<std::vector<int>> nextGrid(GRID_HEIGHT, std::vector<int>(GRID_WIDTH, 0));
void initializeGrid() {
srand(static_cast<unsigned>(time(0))); // Rastgele başlangıç için tohum oluşturur.
for (int y = 0; y < GRID_HEIGHT; ++y) { // Her hücre için
for (int x = 0; x < GRID_WIDTH; ++x) {
grid[y][x] = rand() % 2; // Hücreyi rastgele olarak dolu (1) veya boş (0) yapar.
}
}
}
int countNeighbors(int y, int x) {
int count = 0; // Komşu hücre sayacını sıfırla.
for (int dy = -1; dy <= 1; ++dy) { // -1, 0, 1: komşu hücreler için dikey kayma
for (int dx = -1; dx <= 1; ++dx) { // -1, 0, 1: komşu hücreler için yatay kayma
if (dy == 0 && dx == 0) continue; // Kendisi değil, sadece komşuları kontrol et.
int ny = (y + dy + GRID_HEIGHT) % GRID_HEIGHT; // Dikeyde çevrilebilir koordinat
int nx = (x + dx + GRID_WIDTH) % GRID_WIDTH; // Yatayda çevrilebilir koordinat
count += grid[ny][nx]; // Eğer komşu hücre dolu ise sayacı artır.
}
}
return count; // Bulunan komşu hücrelerin toplam sayısını döndür.
}
void updateGrid() {
for (int y = 0; y < GRID_HEIGHT; ++y) { // Her hücreyi güncelle
for (int x = 0; x < GRID_WIDTH; ++x) {
int neighbors = countNeighbors(y, x); // Mevcut hücrenin komşu sayısını al
if (grid[y][x] == 1) { // Hücre dolu ise
nextGrid[y][x] = (neighbors == 2 || neighbors == 3) ? 1 : 0; // 2 veya 3 komşu ile hayatta kalır.
} else if (grid[y][x] == 2) { // Genişleyen hücre durumu
nextGrid[y][x] = (neighbors >= 1) ? 2 : 0; // Komşuları varsa genişlemeye devam et.
} else { // Hücre boş ise
nextGrid[y][x] = (neighbors == 3) ? 1 : 0; // Boş hücre, 3 komşu varsa doğar.
}
}
}
grid.swap(nextGrid); // Eski durumu yeni durumla değiştir.
}
// Hücreleri çizer.
for (int y = 0; y < GRID_HEIGHT; ++y) {
for (int x = 0; x < GRID_WIDTH; ++x) {
if (grid[y][x] == 1) { // Hücre dolu ise
glColor3f(0.0f, 1.0f, 0.0f); // Yeşil rengi ayarla.
} else if (grid[y][x] == 2) { // Genişleyen hücre ise
glColor3f(0.0f, 1.0f, 0.5f); // Yeşil tonunda bir renk
} else {
glColor3f(0.0f, 0.0f, 0.0f); // Boş hücreler için siyah arka plan
}
glBegin(GL_QUADS); // Her hücreyi kare olarak çiz.
glVertex2f(x * CELL_SIZE, y * CELL_SIZE);
glVertex2f((x + 1) * CELL_SIZE - 1, y * CELL_SIZE);
glVertex2f((x + 1) * CELL_SIZE - 1, (y + 1) * CELL_SIZE - 1);
glVertex2f(x * CELL_SIZE, (y + 1) * CELL_SIZE - 1);
glEnd();
}
}
// Izgara çizgilerini çizer.
glColor3f(1.0f, 0.0f, 0.0f); // Izgara için kırmızı çizgi
glLineWidth(1.0f);
glBegin(GL_LINES);
for (int x = 0; x <= WIDTH; x += CELL_SIZE) {
glVertex2f(x, 0); glVertex2f(x, HEIGHT); // Dikey çizgiler
}
for (int y = 0; y <= HEIGHT; y += CELL_SIZE) {
glVertex2f(0, y); glVertex2f(WIDTH, y); // Yatay çizgiler
}
glEnd();
}
int main() {
if (!glfwInit()) { // GLFW başlat.
return -1;
}
while (!glfwWindowShouldClose(window)) { // Pencere açıkken
drawGrid(); // Çizimi güncelle.
updateGrid(); // Oyun kurallarına göre hücre durumlarını güncelle.
glfwSwapBuffers(window); // Çizimi pencereye uygula.
glfwPollEvents(); // Olayları kontrol et.
}
indirgenemez karmaşıklık olarak bilinen olgu, hayatımızın her safhasında tezahürlerle kendini görünür kılıyor, john conway in yaşam oyunu programı da bu kavramın en yalın göstergelerini içeriyor. https://streamable.com/5cxsmk
John Conway'ın "Game of Life" adlı hücresel otomata modelini kullanan iki boyutlu bir grid (ızgara) üzerinde hücrelerin durumunu simüle eder. Program, belirli hücre kurallarına dayanarak her adımda gridin güncellenmesini sağlar. işte kod üzerinden grid yapısı ve komşuluk kavramının açıklaması:
1. Grid Yapısı
Programın başında tanımlanan grid ve nextGrid adlı iki boyutlu vektörler, hücre durumlarını saklamak için kullanılır. grid, hücrelerin mevcut durumunu temsil ederken, nextGrid bir sonraki durum için geçici depolama alanı sağlar. Grid boyutları, GRID_HEIGHT ve GRID_WIDTH sabitleriyle belirlenir. Bu sayede, her bir hücre bir hücre durumu (canlı veya ölü) ile temsil edilir. Başlangıçta, initializeGrid() fonksiyonu ile grid rastgele canlı ve ölü hücrelerle doldurulur.
2. Komşuluk Kavramı
Her hücrenin komşularıyla etkileşimi, programda countNeighbors(int y, int x) fonksiyonu ile sağlanır. Bu fonksiyon, belirli bir hücre için çevresindeki 8 komşunun durumunu kontrol eder. Komşular, yukarı, aşağı, sol, sağ ve köşelerdeki hücreleri içerir. Bu komşu hücrelerin durumları modüler aritmetik kullanılarak hesaplandığı için, gridin sınırlarına ulaşan hücreler için döngüsel bir davranış sergilenir. Örneğin, bir hücre en üst sıradaysa, yukarıdaki komşusu gridin en alt satırından gelir. Böylece, grid bir torus gibi davranarak sınırlı bir alan içinde sürekli bir etkileşim sağlar.
3. Hücre Durumunun Güncellenmesi
Hücrelerin güncellenmesi updateGrid() fonksiyonu ile gerçekleştirilir. Her bir hücre için komşu sayısı, countNeighbors() fonksiyonu kullanılarak hesaplanır. Daha sonra, Game of Life kurallarına göre hücrenin durumu güncellenir. Eğer hücre canlı ise ve 2 veya 3 komşusu varsa hayatta kalır; aksi halde ölür. Eğer hücre ölü ise ve 3 komşusu varsa, bu hücre canlanır. Bu mantık, her hücrenin durumunu etkileyen bir etkileşim ağı oluşturur ve gridin dinamik bir şekilde evrilmesini sağlar.
4. Görselleştirme ve Renk Hesaplama
drawGrid() fonksiyonu, griddeki hücrelerin görsel temsilini oluşturur. Hücrelerin durumuna göre (canlı ya da ölü) ekranın belirli bölümlerine renkler atanır. Renkler, calculateColor(int gridX, int gridY) fonksiyonu kullanılarak hesaplanır; burada merkezden uzaklaştıkça hücrelerin rengi maviye döner. Bu, griddeki canlı hücrelerin görsel olarak belirgin hale gelmesini sağlar ve simülasyonun estetik bir yönünü ortaya çıkarır.
5. Kullanıcı Etkileşimi ve Kaydırma
Programda kullanıcı, yön tuşları ile griddeki görüntüyü kaydırabilir. processMovement(float deltaTime) fonksiyonu, kullanıcının hangi yön tuşlarına bastığını kontrol eder ve buna göre griddeki hücrelerin görünümünü kaydırır. Bu sayede, geniş bir grid içinde farklı hücre yapılarını keşfetmek mümkündür. Kaydırma işlemi, gridin sınırlarını da dikkate alarak gerçekleştirilir, bu da simülasyonun sürekli ve kesintisiz bir deneyim sunmasını sağlar.
