Upload 6 files

agent_coev.py

@@ -0,0 +1,239 @@
+# swarm_mind_v4/agent_coev.py
+import pygame
+import numpy as np
+import random
+import math
+import neat # NEAT kütüphanesi
+from vector import Vector2D
+# V4 Environment'ı import ediyoruz
+from environment import Environment, FoodSource
+import settings as s
+
+class AgentCoEv:
+    """
+    Ko-evrim simülasyonundaki bir ajan. NEAT tarafından evrimleştirilen bir
+    sinir ağı tarafından kontrol edilir ve kendi kolonisine aittir.
+    """
+    def __init__(self, genome, config, environment: Environment, colony_id: int):
+        """Ajanı genom, config, ortam ve koloni ID ile başlatır."""
+        self.genome = genome
+        self.config = config
+        self.environment = environment
+        self.colony_id = colony_id # Kendi kolonisi (0: Kırmızı, 1: Mavi)
+
+        # Genomdan sinir ağını oluştur
+        self.net = neat.nn.FeedForwardNetwork.create(genome, config)
+
+        # Fiziksel özellikler
+        self.max_speed = s.MAX_SPEED
+        self.max_force = s.MAX_FORCE
+        self.size = s.AGENT_SIZE
+
+        # Sensör parametreleri
+        self.pheromone_sense_dist = s.NN_PHEROMONE_SENSE_DIST
+        self.pheromone_sense_angles = s.NN_PHEROMONE_SENSE_ANGLES
+        self.food_sense_radius = s.NN_FOOD_SENSE_RADIUS
+        self.agent_sense_radius = s.NN_AGENT_SENSE_RADIUS
+
+        # Başlangıç durumunu ayarlamak için reset() çağır
+        self.reset()
+
+
+    def reset(self):
+        """Ajanın durumunu başlangıç koşullarına sıfırlar."""
+        # Başlangıç pozisyonu (kendi yuvasının yakınında)
+        my_nest_pos = self.environment.get_nest_position(self.colony_id)
+        angle = random.uniform(0, 2 * math.pi)
+        start_offset_np = np.array([math.cos(angle), math.sin(angle)]) * s.NEST_RADIUS * 1.2
+        start_pos_np = my_nest_pos + start_offset_np
+        self.position = Vector2D(np.clip(start_pos_np[0], 0, s.SCREEN_WIDTH),
+                                 np.clip(start_pos_np[1], 0, s.SCREEN_HEIGHT))
+
+        self.velocity = Vector2D.random_vector() * (self.max_speed / 2)
+        self.acceleration = Vector2D(0, 0)
+
+        # Durum
+        self.has_food = False
+        # Renk kolonisine göre ayarlanır
+        self.color = s.COLOR_AGENT_RED_SEEKING if self.colony_id == s.COLONY_ID_RED else s.COLOR_AGENT_BLUE_SEEKING
+
+        # Fitness takibi için sayaç
+        self.food_collected_count = 0
+
+
+    def _get_inputs(self, all_agents: list) -> list[float]:
+        """Sinir ağı için girdileri toplar, normalize eder."""
+        inputs = []
+        current_pos_np = np.array([self.position.x, self.position.y])
+
+        # --- Feromon Girdileri (Kendi Kolonisinin, Normalleştirilmiş 0-1) ---
+        current_heading = self.velocity.heading()
+        sample_points_v = []
+        for angle_offset in self.pheromone_sense_angles:
+            angle = current_heading + angle_offset
+            point = self.position + Vector2D(math.cos(angle), math.sin(angle)) * self.pheromone_sense_dist
+            sample_points_v.append(point)
+        sample_points_np = [np.array([p.x, p.y]) for p in sample_points_v]
+
+        # Kendi kolonisine ait 'home' ve 'food' feromonlarını al
+        home_pheromones = self.environment.sense_pheromones_at(self.colony_id, 'home', sample_points_np)
+        food_pheromones = self.environment.sense_pheromones_at(self.colony_id, 'food', sample_points_np)
+
+        inputs.extend(home_pheromones / s.PHEROMONE_MAX_STRENGTH) # 3 girdi
+        inputs.extend(food_pheromones / s.PHEROMONE_MAX_STRENGTH) # 3 girdi
+
+        # --- Bias Girdisi ---
+        inputs.append(1.0) # 1 girdi
+
+        # --- Durum Girdisi ---
+        inputs.append(1.0 if self.has_food else 0.0) # 1 girdi
+
+        # --- Hız Girdisi (Normalleştirilmiş -1 ile 1 arası) ---
+        norm_vel_x = np.clip(self.velocity.x / self.max_speed, -1.0, 1.0)
+        norm_vel_y = np.clip(self.velocity.y / self.max_speed, -1.0, 1.0)
+        inputs.extend([norm_vel_x, norm_vel_y]) # 2 girdi
+
+        # --- Yuva Yönü Girdisi (Kendi Yuvasına, Normalleştirilmiş X, Y) ---
+        my_nest_pos = self.environment.get_nest_position(self.colony_id)
+        nest_vector = my_nest_pos - current_pos_np
+        dist_to_nest_sq = np.sum(nest_vector**2)
+        if dist_to_nest_sq > 1e-6:
+            nest_direction = nest_vector / np.sqrt(dist_to_nest_sq)
+        else:
+            nest_direction = np.zeros(2, dtype=np.float32)
+        inputs.extend(nest_direction) # 2 girdi
+
+        # --- Yem Girdileri (Yön X, Y normalleştirilmiş; Mesafe normalleştirilmiş) ---
+        # Yem kaynakları ortak olduğu için environment'dan direkt alınır
+        closest_food_pos, dist_sq_to_food, food_direction = self.environment.get_closest_food(current_pos_np)
+        if closest_food_pos is not None and dist_sq_to_food < self.food_sense_radius**2 :
+            inputs.extend(food_direction) # 2 girdi
+            normalized_dist = np.sqrt(dist_sq_to_food) / self.food_sense_radius
+            inputs.append(np.clip(normalized_dist, 0.0, 1.0)) # 1 girdi
+        else:
+            inputs.extend([0.0, 0.0]) # Yön yok
+            inputs.append(1.0)        # Mesafe maksimum
+
+        # --- Yakındaki Ajan Yoğunluğu Girdisi (Normalleştirilmiş 0-1) ---
+        # Şimdilik dost/düşman ayrımı yapmıyoruz, toplam yoğunluk
+        nearby_count = 0
+        for other_agent in all_agents:
+            # Ajan listesi artık karışık kolonilerden oluşacak
+            if other_agent is self: continue
+            # Vector2D ile mesafe kontrolü
+            dist_sq = self.position.distance_squared(other_agent.position)
+            if dist_sq < self.agent_sense_radius**2:
+                nearby_count += 1
+        # Normalleştirme (örn: 15 komşu max yoğunluk)
+        density = np.clip(nearby_count / (s.TOTAL_AGENTS / 3.0), 0.0, 1.0) # Toplam ajan sayısına göre oranla
+        inputs.append(density) # 1 girdi
+
+        # Toplam girdi sayısı config ile eşleşmeli (16)
+        assert len(inputs) == s.num_inputs, f"Hata: Girdi sayısı ({len(inputs)}) config ile eşleşmiyor ({s.num_inputs})"
+        return inputs
+
+
+    def update(self, all_agents: list):
+        """Ajanın durumunu sinir ağına ve ortama göre günceller."""
+        # 1. Girdileri Al
+        nn_inputs = self._get_inputs(all_agents)
+
+        # 2. Sinir Ağını Aktive Et
+        nn_outputs = self.net.activate(nn_inputs)
+
+        # 3. Çıktıları Yorumla
+        steer_x = nn_outputs[0] * self.max_force
+        steer_y = nn_outputs[1] * self.max_force
+        steering_force = Vector2D(steer_x, steer_y)
+        deposit_signal = (nn_outputs[2] + 1.0) / 2.0 # tanh için (0,1) aralığı
+        should_deposit_home = deposit_signal > s.NN_OUTPUT_DEPOSIT_THRESHOLD
+
+        # 4. Yönlendirme Kuvvetini Uygula
+        self.apply_force(steering_force)
+
+        # --- Fizik Güncellemesi ---
+        self.velocity += self.acceleration
+        self.velocity.limit(self.max_speed)
+        self.position += self.velocity
+        self.acceleration *= 0
+
+        # --- Ortamla Etkileşim ---
+        current_pos_np = np.array([self.position.x, self.position.y])
+
+        # a. Yuvada mı kontrol et (Yem bırakma - KENDİ YUVASI)
+        if self.has_food and self.environment.is_at_nest(self.colony_id, current_pos_np):
+            self.has_food = False
+            self.food_collected_count += 1
+            # Rengi güncelle
+            self.color = s.COLOR_AGENT_RED_SEEKING if self.colony_id == s.COLONY_ID_RED else s.COLOR_AGENT_BLUE_SEEKING
+
+        # b. Yemde mi kontrol et (Yem alma)
+        if not self.has_food:
+            active_foods = self.environment.get_food_sources()
+            for food_source in active_foods:
+                dist_sq = np.sum((food_source.position - current_pos_np)**2)
+                if dist_sq < (food_source.radius + self.size)**2:
+                    if food_source.take():
+                        self.has_food = True
+                        # Rengi güncelle
+                        self.color = s.COLOR_AGENT_RED_RETURNING if self.colony_id == s.COLONY_ID_RED else s.COLOR_AGENT_BLUE_RETURNING
+                        break # Yem alındı
+
+        # c. Feromon Bırakma (KENDİ KOLONİSİNİN 'home' izi)
+        if should_deposit_home and self.has_food:
+             if random.random() < 0.8:
+                 self.environment.deposit_pheromone(self.colony_id, 'home', current_pos_np, s.PHEROMONE_DEPOSIT_VALUE)
+
+        # --- Kenarlar ve Engeller ---
+        self.edges()
+        self._handle_obstacle_collisions()
+
+
+    def _handle_obstacle_collisions(self):
+        """Engellerle çarpışmayı kontrol eder ve iter (V3'ten aynı)."""
+        agent_pos_np = np.array([self.position.x, self.position.y])
+        for obs in self.environment.obstacles:
+            dist_vec_np = agent_pos_np - obs.position
+            dist_sq = np.sum(dist_vec_np**2)
+            min_dist = obs.radius + self.size * 1.5
+            if dist_sq < min_dist**2 and dist_sq > 1e-6:
+                distance = np.sqrt(dist_sq)
+                penetration = min_dist - distance
+                away_force_dir = dist_vec_np / distance
+                force_magnitude = penetration * self.max_force * 5
+                away_force = Vector2D(away_force_dir[0], away_force_dir[1]) * force_magnitude
+                self.apply_force(away_force)
+                self.velocity *= 0.95
+
+
+    def apply_force(self, force: Vector2D):
+        """İvmeye kuvvet ekler (Aynı)."""
+        self.acceleration += force
+
+    def edges(self):
+        """Ekran kenarlarından sekme (Aynı)."""
+        margin = 5
+        turn_force = Vector2D(0,0)
+        apply_turn = False
+        pos = self.position; vel = self.velocity; max_s = self.max_speed; max_f = self.max_force * 3
+
+        if pos.x < margin: turn_force.x = (max_s - vel.x); apply_turn=True
+        elif pos.x > s.SCREEN_WIDTH - margin: turn_force.x = (-max_s - vel.x); apply_turn=True
+        if pos.y < margin: turn_force.y = (max_s - vel.y); apply_turn=True
+        elif pos.y > s.SCREEN_HEIGHT - margin: turn_force.y = (-max_s - vel.y); apply_turn=True
+
+        if apply_turn:
+             turn_force.limit(max_f)
+             self.apply_force(turn_force)
+
+    def draw(self, screen):
+        """Ajanı kolonisine uygun renkte çizer."""
+        # Rengi __init__ ve update içinde ayarladık
+        current_color = self.color
+        pos_int = (int(self.position.x), int(self.position.y))
+        radius = int(self.size)
+
+        # Basit daire çizimi
+        pygame.draw.circle(screen, current_color, pos_int, radius)
+        if self.has_food: # Yem taşıyorsa içine beyaz daire
+            pygame.draw.circle(screen, (255,255,255), pos_int, int(radius * 0.5))

environment.py

@@ -0,0 +1,350 @@
+# swarm_mind_v4/environment.py
+import pygame
+import numpy as np
+import random
+import settings as s # Ayarları 's' takma adıyla içeri aktar
+
+class FoodSource:
+    """Basit bir yem kaynağı sınıfı (V3'ten aynı)."""
+    def __init__(self, position, initial_amount, radius):
+        self.position = np.array(position, dtype=np.float32)
+        self.amount = initial_amount
+        self.radius = radius
+        self.color = s.COLOR_FOOD
+
+    def take(self) -> bool:
+        if self.amount > 0:
+            self.amount -= 1
+            return True
+        return False
+
+    def is_empty(self) -> bool:
+        return self.amount <= 0
+
+    def draw(self, screen):
+        if self.amount > 0: # Sadece içinde yem varsa çiz
+            brightness = max(0.2, min(1.0, self.amount / s.FOOD_INITIAL_AMOUNT)) # Min parlaklık ekle
+            color = (int(self.color[0] * brightness),
+                     int(self.color[1] * brightness),
+                     int(self.color[2] * brightness))
+            pygame.draw.circle(screen, color, self.position.astype(int), self.radius)
+
+# V3/V4: Engel Sınıfı
+class Obstacle:
+    """Basit dairesel bir engeli temsil eder."""
+    def __init__(self, position, radius):
+        self.position = np.array(position, dtype=np.float32)
+        self.radius = radius
+        self.color = s.COLOR_OBSTACLE
+
+    def draw(self, screen):
+        pygame.draw.circle(screen, self.color, self.position.astype(int), int(self.radius))
+
+class Environment:
+    """
+    Simülasyon ortamını yönetir (V4: İki Koloni, Ayrı Feromonlar, Dinamik Yem, Engeller).
+    """
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+        self.grid_res = s.PHEROMONE_RESOLUTION
+        self.grid_width = width // self.grid_res
+        self.grid_height = height // self.grid_res
+
+        # V4: Koloniye özel feromon ızgaraları
+        self.home_pheromone_grids = {
+            s.COLONY_ID_RED: np.zeros((self.grid_width, self.grid_height), dtype=np.float32),
+            s.COLONY_ID_BLUE: np.zeros((self.grid_width, self.grid_height), dtype=np.float32)
+        }
+        self.food_pheromone_grids = {
+             s.COLONY_ID_RED: np.zeros((self.grid_width, self.grid_height), dtype=np.float32),
+             s.COLONY_ID_BLUE: np.zeros((self.grid_width, self.grid_height), dtype=np.float32)
+        }
+
+        # V4: İki Yuva
+        self.nest_positions = {
+            s.COLONY_ID_RED: s.NEST_POS_RED.astype(np.float32),
+            s.COLONY_ID_BLUE: s.NEST_POS_BLUE.astype(np.float32)
+        }
+        self.nest_radius = s.NEST_RADIUS
+        self.nest_colors = {
+             s.COLONY_ID_RED: s.COLOR_NEST_RED,
+             s.COLONY_ID_BLUE: s.COLOR_NEST_BLUE
+        }
+
+        # Dinamik Yem Kaynakları
+        self.food_sources = []
+
+        # Engeller
+        self.obstacles = self._create_obstacles()
+
+        # Başlangıç yemleri
+        for _ in range(s.MAX_FOOD_SOURCES // 2):
+              self._try_spawn_food()
+
+        # Feromonları çizmek için yüzey
+        self.pheromone_surface = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+
+    def _create_obstacles(self):
+        """Ortama rastgele engeller yerleştirir."""
+        obstacles = []
+        attempts = 0
+        max_attempts = s.NUM_OBSTACLES * 15
+
+        while len(obstacles) < s.NUM_OBSTACLES and attempts < max_attempts:
+            attempts += 1
+            radius = random.uniform(s.OBSTACLE_MIN_RADIUS, s.OBSTACLE_MAX_RADIUS)
+            margin = radius + 20
+            pos = np.array([random.uniform(margin, self.width - margin),
+                            random.uniform(margin, self.height - margin)], dtype=np.float32)
+
+            # Yuvalarla çarpışıyor mu?
+            nest_collision = False
+            for nest_pos in self.nest_positions.values():
+                 if np.linalg.norm(pos - nest_pos) < self.nest_radius + radius + 15:
+                      nest_collision = True
+                      break
+            if nest_collision: continue
+
+            # Diğer engellerle çarpışıyor mu?
+            obstacle_collision = False
+            for obs in obstacles:
+                if np.linalg.norm(pos - obs.position) < obs.radius + radius + 10:
+                    obstacle_collision = True
+                    break
+            if not obstacle_collision:
+                obstacles.append(Obstacle(pos, radius))
+
+        print(f"Created {len(obstacles)} obstacles.")
+        return obstacles
+
+    def _try_spawn_food(self):
+        """Ortama yeni bir yem kaynağı eklemeyi dener."""
+        if len(self.food_sources) >= s.MAX_FOOD_SOURCES: return
+
+        attempts = 0
+        max_attempts = 30
+        while attempts < max_attempts:
+            attempts += 1
+            margin = s.FOOD_RADIUS + 15
+            pos = np.array([random.uniform(margin, self.width - margin),
+                            random.uniform(margin, self.height - margin)], dtype=np.float32)
+
+            # Yuvalarla çarpışıyor mu?
+            nest_collision = False
+            for nest_pos in self.nest_positions.values():
+                 if np.linalg.norm(pos - nest_pos) < self.nest_radius + s.FOOD_RADIUS + 25:
+                      nest_collision = True
+                      break
+            if nest_collision: continue
+
+            # Engellerle çarpışıyor mu?
+            obstacle_collision = False
+            for obs in self.obstacles:
+                if np.linalg.norm(pos - obs.position) < obs.radius + s.FOOD_RADIUS + 15:
+                    obstacle_collision = True
+                    break
+            if obstacle_collision: continue
+
+             # Diğer yem kaynaklarına çok yakın mı?
+            food_collision = False
+            for fs in self.food_sources:
+                 if np.linalg.norm(pos - fs.position) < s.FOOD_RADIUS * 5:
+                      food_collision = True
+                      break
+            if food_collision: continue
+
+            # Uygun yer bulundu
+            self.food_sources.append(FoodSource(pos, s.FOOD_INITIAL_AMOUNT, s.FOOD_RADIUS))
+            return
+
+    def update(self):
+        """Ortamı her adımda günceller."""
+        self._update_pheromones()
+
+        # Yem Kaynaklarını Yönet
+        if s.FOOD_DEPLETION_REMOVAL:
+            self.food_sources = [fs for fs in self.food_sources if not fs.is_empty()]
+        if random.random() < s.FOOD_SPAWN_RATE:
+            self._try_spawn_food()
+
+    def world_to_grid(self, world_pos: np.ndarray) -> tuple[int, int]:
+        """Dünya koordinatlarını ızgara indekslerine dönüştürür."""
+        gx = int(world_pos[0] / self.grid_res)
+        gy = int(world_pos[1] / self.grid_res)
+        gx = np.clip(gx, 0, self.grid_width - 1)
+        gy = np.clip(gy, 0, self.grid_height - 1)
+        return gx, gy
+
+    def deposit_pheromone(self, colony_id: int, pheromone_type: str, world_pos: np.ndarray, amount: float):
+        """Belirtilen konuma, belirtilen koloninin feromonunu bırakır."""
+        gx, gy = self.world_to_grid(world_pos)
+        # Doğru ızgarayı seç
+        if pheromone_type == 'home':
+            grid = self.home_pheromone_grids.get(colony_id) # .get() ile None dönebilir
+        elif pheromone_type == 'food':
+             grid = self.food_pheromone_grids.get(colony_id)
+        else:
+            grid = None # Bilinmeyen tür veya hatalı colony_id
+
+        if grid is not None:
+            grid[gx, gy] += amount
+            grid[gx, gy] = np.clip(grid[gx, gy], 0, s.PHEROMONE_MAX_STRENGTH)
+
+    def _diffuse_and_evaporate(self, grid: np.ndarray) -> np.ndarray:
+        """Tek bir feromon ızgarasını günceller."""
+        padded_grid = np.pad(grid, 1, mode='constant')
+        center_weight = 1.0 - (s.PHEROMONE_DIFFUSION_RATE * 8)
+        neighbor_weight = s.PHEROMONE_DIFFUSION_RATE
+        # Komşuların ağırlıklı toplamı (daha okunabilir)
+        neighbors_sum = (padded_grid[:-2, 1:-1] + padded_grid[2:, 1:-1] +   # Yukarı/Aşağı
+                         padded_grid[1:-1, :-2] + padded_grid[1:-1, 2:] +   # Sol/Sağ
+                         padded_grid[:-2, :-2] + padded_grid[:-2, 2:] +     # SolÜst/SağÜst
+                         padded_grid[2:, :-2] + padded_grid[2:, 2:])        # SolAlt/SağAlt
+        diffused = (padded_grid[1:-1, 1:-1] * center_weight + neighbors_sum * neighbor_weight)
+        evaporated = diffused * (1.0 - s.PHEROMONE_EVAPORATION_RATE)
+        return np.clip(evaporated, 0, s.PHEROMONE_MAX_STRENGTH)
+
+    def _update_pheromones(self):
+        """Tüm feromon ızgaralarını günceller."""
+        for colony_id in self.home_pheromone_grids:
+            self.home_pheromone_grids[colony_id] = self._diffuse_and_evaporate(self.home_pheromone_grids[colony_id])
+            self.food_pheromone_grids[colony_id] = self._diffuse_and_evaporate(self.food_pheromone_grids[colony_id])
+
+    def get_pheromone_strength(self, colony_id: int, pheromone_type: str, world_pos: np.ndarray) -> float:
+        """Belirtilen koloninin, belirtilen türdeki feromon gücünü alır."""
+        gx, gy = self.world_to_grid(world_pos)
+        if pheromone_type == 'home':
+            grid = self.home_pheromone_grids.get(colony_id)
+        elif pheromone_type == 'food':
+             grid = self.food_pheromone_grids.get(colony_id)
+        else: return 0.0
+
+        return grid[gx, gy] if grid is not None else 0.0
+
+    def sense_pheromones_at(self, colony_id: int, pheromone_type: str, sample_points: list[np.ndarray]) -> np.ndarray:
+        """Verilen noktalardaki belirtilen koloniye ait feromon yoğunluklarını döndürür."""
+        strengths = []
+        # Doğru ızgarayı seç
+        if pheromone_type == 'home':
+            grid = self.home_pheromone_grids.get(colony_id)
+        elif pheromone_type == 'food':
+             grid = self.food_pheromone_grids.get(colony_id)
+        else: grid = None
+
+        if grid is None: return np.zeros(len(sample_points), dtype=np.float32)
+
+        for point in sample_points:
+            gx, gy = self.world_to_grid(point)
+            strengths.append(grid[gx, gy])
+        return np.array(strengths, dtype=np.float32)
+
+    def get_food_sources(self) -> list[FoodSource]:
+        """Aktif yem kaynaklarının listesi."""
+        return [fs for fs in self.food_sources if not fs.is_empty()]
+
+    # === Bu metot environment.py içinde olmalı ===
+    def get_closest_food(self, world_pos: np.ndarray) -> tuple[np.ndarray | None, float, np.ndarray]:
+        """Verilen konuma en yakın aktif yem kaynağını bulur.
+           Döndürülenler: (kaynak_pozisyonu, uzaklık_karesi, yön_vektörü_normalize)
+           Eğer kaynak yoksa: (None, float('inf'), np.zeros(2))
+        """
+        closest_fs = None
+        min_dist_sq = float('inf')
+        active_foods = self.get_food_sources() # Aktif olanları al
+
+        for fs in active_foods:
+            dist_sq = np.sum((fs.position - world_pos)**2)
+            if dist_sq < min_dist_sq:
+                min_dist_sq = dist_sq
+                closest_fs = fs
+
+        if closest_fs:
+            direction_vec = closest_fs.position - world_pos
+            dist = np.sqrt(min_dist_sq)
+            if dist > 1e-6:
+                normalized_direction = direction_vec / dist
+            else:
+                normalized_direction = np.zeros(2, dtype=np.float32)
+            return closest_fs.position, min_dist_sq, normalized_direction
+        else:
+            return None, float('inf'), np.zeros(2, dtype=np.float32)
+    # ============================================
+
+    def get_nest_position(self, colony_id: int) -> np.ndarray:
+        """Belirtilen koloninin yuva pozisyonunu döndürür."""
+        return self.nest_positions.get(colony_id) # .get() ile None dönebilir
+
+    def is_at_nest(self, colony_id: int, world_pos: np.ndarray) -> bool:
+        """Pozisyonun belirtilen koloninin yuvasında olup olmadığını kontrol eder."""
+        nest_pos = self.nest_positions.get(colony_id)
+        if nest_pos is None: return False
+        return np.linalg.norm(world_pos - nest_pos) < self.nest_radius
+
+    def check_obstacle_collision(self, world_pos: np.ndarray, radius: float) -> bool:
+        """Engelle çarpışma kontrolü."""
+        for obs in self.obstacles:
+            if np.linalg.norm(world_pos - obs.position) < obs.radius + radius:
+                return True
+        return False
+
+    def draw(self, screen):
+        """Ortamın tüm bileşenlerini çizer."""
+        if s.DEBUG_DRAW_PHEROMONES:
+            self._draw_pheromones(screen)
+        if s.DEBUG_DRAW_NESTS:
+            self._draw_nests(screen)
+        if s.DEBUG_DRAW_FOOD_LOCATIONS:
+            self._draw_food_sources(screen)
+        if s.DEBUG_DRAW_OBSTACLES:
+            self._draw_obstacles(screen)
+
+    def _draw_pheromones(self, screen):
+        """Her iki koloninin feromonlarını ayrı renklerle çizer."""
+        self.pheromone_surface.fill((0, 0, 0, 0))
+        res = self.grid_res
+        pheromone_colors = {
+            'home_red': s.COLOR_PHEROMONE_HOME_RED,
+            'home_blue': s.COLOR_PHEROMONE_HOME_BLUE,
+            'food_red': (*s.COLOR_PHEROMONE_HOME_RED[:3], s.COLOR_PHEROMONE_HOME_RED[3] // 2), # Daha soluk
+            'food_blue': (*s.COLOR_PHEROMONE_HOME_BLUE[:3], s.COLOR_PHEROMONE_HOME_BLUE[3] // 2) # Daha soluk
+        }
+        grids_to_draw = {
+            'home_red': self.home_pheromone_grids.get(s.COLONY_ID_RED),
+            'home_blue': self.home_pheromone_grids.get(s.COLONY_ID_BLUE),
+            'food_red': self.food_pheromone_grids.get(s.COLONY_ID_RED),
+            'food_blue': self.food_pheromone_grids.get(s.COLONY_ID_BLUE)
+        }
+
+        for p_type, grid in grids_to_draw.items():
+            if grid is None: continue # Izgara yoksa atla
+            color_info = pheromone_colors[p_type]
+            for x in range(self.grid_width):
+                for y in range(self.grid_height):
+                    strength = grid[x, y]
+                    if strength > 0.01:
+                        alpha = int(np.clip(strength / s.PHEROMONE_MAX_STRENGTH, 0, 1) * color_info[3])
+                        color = (*color_info[:3], alpha)
+                        rect = pygame.Rect(x * res, y * res, res, res)
+                        pygame.draw.rect(self.pheromone_surface, color, rect)
+
+        screen.blit(self.pheromone_surface, (0, 0))
+
+
+    def _draw_nests(self, screen):
+        """Her iki yuvayı da çizer."""
+        for colony_id, nest_pos in self.nest_positions.items():
+            color = self.nest_colors.get(colony_id, (128,128,128)) # Hata durumunda gri
+            pygame.draw.circle(screen, color, nest_pos.astype(int), self.nest_radius)
+            pygame.draw.circle(screen, (color[0]//2, color[1]//2, color[2]//2),
+                               nest_pos.astype(int), self.nest_radius - 3)
+
+    def _draw_food_sources(self, screen):
+        """Aktif yem kaynaklarını çizer."""
+        for fs in self.food_sources:
+            fs.draw(screen)
+
+    def _draw_obstacles(self, screen):
+        """Engelleri çizer."""
+        for obs in self.obstacles:
+            obs.draw(screen)

main_coev.py

@@ -0,0 +1,293 @@
+# swarm_mind_v4/main_coev.py
+import pygame
+import sys
+import os
+import neat # NEAT kütüphanesi
+import numpy as np
+import pickle # Genomları kaydetmek/yüklemek için
+import random
+import time # Zaman ölçümü için
+import settings as s
+from environment import Environment # V4 Environment
+from agent_coev import AgentCoEv # V4 Agent
+
+# --- Tek Bir Eşleşmeyi Simüle Etme Fonksiyonu ---
+def eval_simulation(genome_red, config_red, genome_blue, config_blue):
+    """
+    Bir kırmızı ve bir mavi genom arasındaki tek bir maçı simüle eder.
+    Her iki koloninin topladığı yem miktarını döndürür.
+    """
+    # Ağları oluştur
+    net_red = neat.nn.FeedForwardNetwork.create(genome_red, config_red)
+    net_blue = neat.nn.FeedForwardNetwork.create(genome_blue, config_blue)
+
+    # Ortamı oluştur
+    environment = Environment(s.SCREEN_WIDTH, s.SCREEN_HEIGHT)
+
+    # Ajanları oluştur (her koloni kendi ağını kullanır)
+    agents_red = [AgentCoEv(genome_red, config_red, environment, s.COLONY_ID_RED) for _ in range(s.NUM_AGENTS_PER_COLONY)]
+    agents_blue = [AgentCoEv(genome_blue, config_blue, environment, s.COLONY_ID_BLUE) for _ in range(s.NUM_AGENTS_PER_COLONY)]
+    all_agents = agents_red + agents_blue
+
+    # --- Simülasyon Döngüsü (Görselleştirmesiz) ---
+    for step in range(s.SIMULATION_STEPS_PER_GEN):
+        environment.update()
+        # Ajanları rastgele sırada güncellemek yanlılığı azaltabilir
+        random.shuffle(all_agents)
+        for agent in all_agents:
+            # update metodu artık tüm ajan listesini alıyor
+            agent.update(all_agents)
+
+    # --- Sonuçları Hesapla ---
+    food_red = sum(agent.food_collected_count for agent in agents_red)
+    food_blue = sum(agent.food_collected_count for agent in agents_blue)
+
+    return food_red, food_blue
+
+# --- Ko-evrim Sürecini Başlatma Fonksiyonu ---
+def run_coev(config_file):
+    """
+    İki popülasyon için NEAT ko-evrim sürecini yönetir.
+    """
+    # NEAT yapılandırmasını yükle
+    config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction,
+                         neat.DefaultSpeciesSet, neat.DefaultStagnation,
+                         config_file)
+
+    # --- Popülasyonları Oluştur veya Yükle ---
+    checkpoint_dir_red = 'swarm_mind_v4/checkpoints_red'
+    checkpoint_dir_blue = 'swarm_mind_v4/checkpoints_blue'
+    os.makedirs(checkpoint_dir_red, exist_ok=True)
+    os.makedirs(checkpoint_dir_blue, exist_ok=True)
+
+    try:
+        p_red = neat.Checkpointer.restore_checkpoint(os.path.join(checkpoint_dir_red, 'neat-checkpoint-'))
+        print("Kırmızı popülasyon checkpoint'ten yüklendi.")
+    except Exception:
+        print("Kırmızı popülasyon checkpoint bulunamadı, yeni oluşturuluyor.")
+        p_red = neat.Population(config)
+
+    try:
+        p_blue = neat.Checkpointer.restore_checkpoint(os.path.join(checkpoint_dir_blue, 'neat-checkpoint-'))
+        print("Mavi popülasyon checkpoint'ten yüklendi.")
+    except Exception:
+        print("Mavi popülasyon checkpoint bulunamadı, yeni oluşturuluyor.")
+        p_blue = neat.Population(config)
+
+    # --- Raporlayıcıları Ekle ---
+    # Kırmızı Popülasyon
+    p_red.add_reporter(neat.StdOutReporter(True))
+    stats_red = neat.StatisticsReporter()
+    p_red.add_reporter(stats_red)
+    p_red.add_reporter(neat.Checkpointer(generation_interval=5, filename_prefix=os.path.join(checkpoint_dir_red, 'neat-checkpoint-')))
+    # Mavi Popülasyon
+    # İkinci StdOutReporter'ı eklemeyebiliriz, çıktılar karışmasın diye
+    # p_blue.add_reporter(neat.StdOutReporter(True)) # Veya sadece mavi için ayrı bir prefix ile
+    stats_blue = neat.StatisticsReporter()
+    p_blue.add_reporter(stats_blue)
+    p_blue.add_reporter(neat.Checkpointer(generation_interval=5, filename_prefix=os.path.join(checkpoint_dir_blue, 'neat-checkpoint-')))
+
+    # --- Özel Nesil Döngüsü ---
+    for generation in range(s.NUM_GENERATIONS):
+        start_time = time.time()
+        print(f"\n****** Ko-Evrim Nesil {generation} Başladı ******")
+
+        # Mevcut neslin genomlarını al (sözlük olarak: {genome_id: genome})
+        genomes_red_dict = p_red.population
+        genomes_blue_dict = p_blue.population
+        # Liste olarak da alabiliriz (eşleşme için daha kolay olabilir)
+        genomes_red_list = list(genomes_red_dict.items())
+        genomes_blue_list = list(genomes_blue_dict.items())
+
+        # Her genomun bu nesildeki maç skorlarını saklamak için
+        # Anahtar: genome_id, Değer: [(kendi_skoru, rakip_skoru), ...] listesi
+        genome_scores_red = {gid: [] for gid, _ in genomes_red_list}
+        genome_scores_blue = {gid: [] for gid, _ in genomes_blue_list}
+
+        # --- Eşleştirme ve Değerlendirme ---
+        eval_count = 0
+        # Her kırmızı genomu, rastgele K mavi genoma karşı test et
+        for gid_r, genome_r in genomes_red_list:
+            # Rastgele K rakip seç (eğer mavi popülasyon K'dan küçükse hepsiyle eşleşir)
+            num_opponents = min(s.NUM_OPPONENTS_PER_EVAL, len(genomes_blue_list))
+            opponents = random.sample(genomes_blue_list, num_opponents)
+
+            for gid_b, genome_b in opponents:
+                # Simülasyonu çalıştır
+                food_r, food_b = eval_simulation(genome_r, config, genome_b, config)
+                eval_count += 1
+
+                # Sonuçları her iki genom için de kaydet
+                genome_scores_red[gid_r].append((food_r, food_b))
+                genome_scores_blue[gid_b].append((food_b, food_r)) # Rakibin skorunu kendi skoru olarak kaydet
+
+        print(f"Nesil {generation}: {eval_count} eşleşme değerlendirildi.")
+
+        # --- Fitness Hesaplama ve Atama ---
+        # Kırmızı genomlar için
+        for gid, genome in genomes_red_dict.items():
+            scores = genome_scores_red[gid]
+            if not scores: # Eğer hiç maç yapmadıysa (popülasyon çok küçükse olabilir)
+                genome.fitness = 0.0
+                continue
+            avg_my_food = np.mean([s[0] for s in scores])
+            avg_opp_food = np.mean([s[1] for s in scores])
+
+            if s.FITNESS_METHOD == 'competitive':
+                genome.fitness = avg_my_food - avg_opp_food
+            else: # 'absolute'
+                genome.fitness = avg_my_food
+
+        # Mavi genomlar için
+        for gid, genome in genomes_blue_dict.items():
+            scores = genome_scores_blue[gid]
+            if not scores:
+                genome.fitness = 0.0
+                continue
+            avg_my_food = np.mean([s[0] for s in scores])
+            avg_opp_food = np.mean([s[1] for s in scores])
+
+            if s.FITNESS_METHOD == 'competitive':
+                genome.fitness = avg_my_food - avg_opp_food
+            else: # 'absolute'
+                genome.fitness = avg_my_food
+
+        # --- NEAT Üreme ve Raporlama Adımları (Manuel) ---
+        # Raporlayıcıları bilgilendir ve sonraki nesli oluştur
+        best_genome_red = max(genomes_red_dict.values(), key=lambda g: g.fitness)
+        best_genome_blue = max(genomes_blue_dict.values(), key=lambda g: g.fitness)
+
+        p_red.reporters.post_evaluate(config, genomes_red_dict, p_red.species, best_genome_red)
+        p_blue.reporters.post_evaluate(config, genomes_blue_dict, p_blue.species, best_genome_blue)
+
+        p_red.reporters.end_generation(config, genomes_red_dict, p_red.species)
+        p_blue.reporters.end_generation(config, genomes_blue_dict, p_blue.species)
+
+        # Sonraki nesilleri oluştur
+        p_red.population = p_red.reproduction.reproduce(config, p_red.species, config.pop_size, generation)
+        p_blue.population = p_blue.reproduction.reproduce(config, p_blue.species, config.pop_size, generation)
+
+        # Yeni nesil için türleri ayarla (checkpoint'ten sonra gerekli olabilir)
+        if not p_red.species or not p_blue.species:
+             p_red.species = config.species_set_type(config, p_red.reporters)
+             p_blue.species = config.species_set_type(config, p_blue.reporters)
+        p_red.species.speciate(config, p_red.population, generation)
+        p_blue.species.speciate(config, p_blue.population, generation)
+
+        # Raporlayıcıları yeni nesil için başlat
+        p_red.reporters.start_generation(generation + 1)
+        p_blue.reporters.start_generation(generation + 1)
+
+        end_time = time.time()
+        print(f"Nesil {generation} tamamlandı. Süre: {end_time - start_time:.2f} saniye")
+
+
+    # --- Evrim Sonrası ---
+    print('\nKo-Evrim tamamlandı.')
+
+    # En iyi genomları bul (popülasyonlar artık bir sonraki nesli içeriyor olabilir,
+    # istatistiklerden veya kaydedilenlerden almak daha güvenli olabilir)
+    # Şimdilik popülasyon içindeki en iyiyi varsayalım (dikkatli olunmalı)
+    try:
+         winner_red = max(p_red.population.values(), key=lambda g: g.fitness if g.fitness is not None else -float('inf'))
+         winner_blue = max(p_blue.population.values(), key=lambda g: g.fitness if g.fitness is not None else -float('inf'))
+
+         print('\nEn İyi Kırmızı Genom:')
+         print(winner_red)
+         print('\nEn İyi Mavi Genom:')
+         print(winner_blue)
+
+         # En iyi genomları kaydet
+         os.makedirs('swarm_mind_v4/best_genomes', exist_ok=True)
+         with open('swarm_mind_v4/best_genomes/winner_red.pkl', 'wb') as f:
+             pickle.dump(winner_red, f)
+         with open('swarm_mind_v4/best_genomes/winner_blue.pkl', 'wb') as f:
+             pickle.dump(winner_blue, f)
+         print("En iyi genomlar 'best_genomes' klasörüne kaydedildi.")
+
+         # İsteğe bağlı görselleştirme
+         if s.VISUALIZE_BEST_GENOMES:
+             visualize_simulation(winner_red, config, winner_blue, config)
+
+    except Exception as e:
+         print(f"\nEvrim sonrası hata (En iyi genom bulunamadı veya kaydedilemedi): {e}")
+
+
+# --- Görselleştirme Fonksiyonu (V4 için güncellendi) ---
+def visualize_simulation(genome_red, config_red, genome_blue, config_blue):
+    """
+    İki rakip genomun davranışını Pygame ile görselleştirir.
+    """
+    print("\nEn iyi Kırmızı ve Mavi genomların maçı görselleştiriliyor...")
+    pygame.init()
+    screen = pygame.display.set_mode((s.SCREEN_WIDTH, s.SCREEN_HEIGHT))
+    pygame.display.set_caption(f"{s.WINDOW_TITLE} - Best Genomes Match")
+    clock = pygame.time.Clock()
+
+    environment = Environment(s.SCREEN_WIDTH, s.SCREEN_HEIGHT)
+    net_red = neat.nn.FeedForwardNetwork.create(genome_red, config_red)
+    net_blue = neat.nn.FeedForwardNetwork.create(genome_blue, config_blue)
+    agents_red = [AgentCoEv(genome_red, config_red, environment, s.COLONY_ID_RED) for _ in range(s.NUM_AGENTS_PER_COLONY)]
+    agents_blue = [AgentCoEv(genome_blue, config_blue, environment, s.COLONY_ID_BLUE) for _ in range(s.NUM_AGENTS_PER_COLONY)]
+    all_agents = agents_red + agents_blue
+
+    running = True
+    sim_step = 0
+    max_vis_steps = s.SIMULATION_STEPS_PER_GEN * 2 # Görselleştirmeyi biraz daha uzun tutalım
+    while running and sim_step < max_vis_steps:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT: running = False; break
+            if event.type == pygame.KEYDOWN:
+                 if event.key == pygame.K_p: s.DEBUG_DRAW_PHEROMONES = not s.DEBUG_DRAW_PHEROMONES
+                 if event.key == pygame.K_ESCAPE: running = False; break
+        if not running: break
+
+        environment.update()
+        random.shuffle(all_agents)
+        for agent in all_agents:
+            agent.update(all_agents)
+
+        screen.fill(s.COLOR_BACKGROUND)
+        environment.draw(screen)
+        for agent in all_agents:
+            agent.draw(screen)
+
+        # Bilgi metinleri
+        font = pygame.font.SysFont(None, 24)
+        food_r = sum(a.food_collected_count for a in agents_red)
+        food_b = sum(a.food_collected_count for a in agents_blue)
+        info_text = font.render(f"Adım: {sim_step}/{max_vis_steps} | Kırmızı Yem: {food_r} | Mavi Yem: {food_b}", True, (255, 255, 255))
+        screen.blit(info_text, (10, 10))
+
+        pygame.display.flip()
+        clock.tick(s.VISUALIZATION_FPS)
+        sim_step += 1
+
+    pygame.quit()
+    print("Görselleştirme tamamlandı.")
+
+
+# --- Ana Çalıştırma Bloğu ---
+if __name__ == '__main__':
+    local_dir = os.path.dirname(__file__)
+    config_path = os.path.join(local_dir, 'neat_config_v4.txt')
+
+    if not os.path.exists(config_path):
+        print(f"HATA: NEAT config dosyası bulunamadı: {config_path}")
+        sys.exit(1)
+
+    print("SwarmMind V4.0 - Co-evolutionary Competition başlatılıyor...")
+    print(f"NEAT Yapılandırması: {config_path}")
+    print(f"Jenerasyon Sayısı: {s.NUM_GENERATIONS}")
+    print(f"Popülasyon Büyüklüğü/Koloni: (config dosyasında belirtilir)")
+    print(f"Simülasyon Adım Sayısı/Eşleşme: {s.SIMULATION_STEPS_PER_GEN}")
+    print(f"Ajan Sayısı/Koloni: {s.NUM_AGENTS_PER_COLONY}")
+    print(f"Rakip Sayısı/Değerlendirme: {s.NUM_OPPONENTS_PER_EVAL}")
+    print(f"Fitness Yöntemi: {s.FITNESS_METHOD}")
+
+    # Gerekli klasörleri oluştur
+    os.makedirs('swarm_mind_v4/checkpoints_red', exist_ok=True)
+    os.makedirs('swarm_mind_v4/checkpoints_blue', exist_ok=True)
+    os.makedirs('swarm_mind_v4/best_genomes', exist_ok=True)
+
+    run_coev(config_path)

neat_config_v4.txt

@@ -0,0 +1,98 @@
+# swarm_mind_v4/neat_config_v4.txt
+
+[NEAT]
+fitness_criterion     = max
+# Rekabetçi fitness negatif olabileceği için threshold dikkatli ayarlanmalı
+# Hedef (rekabetçi) fitness (bu değere ulaşılırsa evrim durur)
+fitness_threshold     = 5000
+# Popülasyon büyüklüğü (Hız için düşük)
+pop_size              = 30
+reset_on_extinction   = False
+
+[DefaultGenome]
+# Girdi (16 adet - V3 ile aynı, şimdilik)
+num_inputs              = 16
+# Çıktı (3 adet - V3 ile aynı)
+num_outputs             = 3
+# Başlangıçta gizli nöron yok
+num_hidden              = 0
+
+# --- Diğer Genom Parametreleri ---
+# Varsayılan aktivasyon fonksiyonu
+activation_default      = tanh
+activation_mutate_rate  = 0.1
+activation_options      = tanh sigmoid relu clamped gaussian
+
+aggregation_default     = sum
+aggregation_mutate_rate = 0.0
+aggregation_options     = sum product min max mean median
+
+bias_init_mean          = 0.0
+bias_init_stdev         = 1.0
+bias_max_value          = 10.0
+bias_min_value          = -10.0
+# Bias mutasyonunun ne kadar güçlü olacağı
+bias_mutate_power       = 0.5
+# Bias değerlerinin mutasyona uğrama oranı
+bias_mutate_rate        = 0.7
+# Bias değerinin tamamen değişme oranı
+bias_replace_rate       = 0.1
+
+compatibility_disjoint_coefficient = 1.0
+compatibility_weight_coefficient = 0.5
+
+# Yeni bağlantı ekleme olasılığı
+conn_add_prob           = 0.1
+# Bağlantı silme olasılığı
+conn_delete_prob        = 0.05
+
+enabled_default         = True
+enabled_mutate_rate     = 0.01
+
+# Geri beslemesiz ağ (FeedForward)
+feed_forward            = True
+# Başlangıç bağlantı tipi (full_direct: tüm girdiler çıktılara bağlı)
+initial_connection      = full_direct
+
+# Yeni nöron ekleme olasılığı
+node_add_prob           = 0.05
+# Nöron silme olasılığı
+node_delete_prob        = 0.02
+
+response_init_mean      = 1.0
+response_init_stdev     = 0.0
+response_max_value      = 10.0
+response_min_value      = -10.0
+response_mutate_power   = 0.0
+response_mutate_rate    = 0.0
+response_replace_rate   = 0.0
+
+weight_init_mean        = 0.0
+weight_init_stdev       = 1.0
+weight_max_value        = 10.0
+weight_min_value        = -10.0
+# Ağırlık mutasyonunun ne kadar güçlü olacağı
+weight_mutate_power     = 0.5
+# Ağırlıkların mutasyona uğrama oranı
+weight_mutate_rate      = 0.8
+# Ağırlıkların tamamen değişme oranı
+weight_replace_rate     = 0.1
+
+
+[DefaultSpeciesSet]
+# Tür uyumluluk eşiği
+compatibility_threshold = 3.0
+
+[DefaultStagnation]
+# Türün fitness'ı en iyi bireye göre mi ortalamaya göre mi?
+species_fitness_func = max
+# Bir tür kaç nesil gelişmezse yok sayılır
+max_stagnation       = 25
+# Her türden kaç en iyi birey korunur
+species_elitism      = 2
+
+[DefaultReproduction]
+# Popülasyonun kaç en iyi bireyi doğrudan sonraki nesle geçer
+elitism              = 2
+# Tür içindeki bireylerin ne kadarının üremeye katılabileceği
+survival_threshold   = 0.2

settings.py

@@ -0,0 +1,91 @@
+# swarm_mind_v4/settings.py
+import pygame
+import numpy as np
+import random
+
+# --- Temel Ekran ve Simülasyon Ayarları ---
+SCREEN_WIDTH = 1280
+SCREEN_HEIGHT = 720
+FPS = 60 # Görselleştirme FPS'i
+WINDOW_TITLE = "SwarmMind V4.0 - Co-evolutionary Competition"
+SIMULATION_STEPS_PER_GEN = 800 # Her eşli değerlendirme için adım sayısı (Hız için düşük)
+NUM_GENERATIONS = 100 # Toplam evrimleştirilecek nesil sayısı
+
+# --- Koloni Ayarları ---
+COLONY_ID_RED = 0
+COLONY_ID_BLUE = 1
+NUM_AGENTS_PER_COLONY = 15 # Koloni başına ajan sayısı (Hız için düşük)
+TOTAL_AGENTS = NUM_AGENTS_PER_COLONY * 2
+
+# --- Renkler ---
+COLOR_BACKGROUND = (10, 10, 30)
+# Kırmızı Koloni
+COLOR_AGENT_RED_SEEKING = (255, 100, 100)
+COLOR_AGENT_RED_RETURNING = (255, 180, 180)
+COLOR_PHEROMONE_HOME_RED = (200, 0, 0, 150) # Kırmızı yuva izi
+# Mavi Koloni
+COLOR_AGENT_BLUE_SEEKING = (100, 100, 255)
+COLOR_AGENT_BLUE_RETURNING = (180, 180, 255)
+COLOR_PHEROMONE_HOME_BLUE = (0, 0, 200, 150) # Mavi yuva izi
+# Ortak Renkler
+COLOR_NEST_RED = (255, 50, 0)   # Kırmızı yuva
+COLOR_NEST_BLUE = (0, 50, 255)  # Mavi yuva
+COLOR_FOOD = (50, 255, 50)      # Yem rengi (Yeşil)
+COLOR_OBSTACLE = (100, 100, 100)
+
+# --- Ajan Ayarları (Temel Fizik) ---
+AGENT_SIZE = 7
+MAX_SPEED = 3.5
+MAX_FORCE = 0.2
+
+# --- Ortam Ayarları (V4 - İki Yuva, Dinamik Yem) ---
+# Yuvaları ekranın iki yanına yerleştirelim
+NEST_POS_RED = np.array([100, SCREEN_HEIGHT / 2], dtype=np.float32)
+NEST_POS_BLUE = np.array([SCREEN_WIDTH - 100, SCREEN_HEIGHT / 2], dtype=np.float32)
+NEST_RADIUS = 30
+
+# Yem Kaynakları (Dinamik)
+MAX_FOOD_SOURCES = 10
+FOOD_RADIUS = 10
+FOOD_INITIAL_AMOUNT = 40
+FOOD_SPAWN_RATE = 0.015
+# Yem bitince kaynak ortamdan silinsin mi?
+FOOD_DEPLETION_REMOVAL = True  # <--- EKLENEN SATIR
+
+# Engeller
+NUM_OBSTACLES = 6
+OBSTACLE_MIN_RADIUS = 15
+OBSTACLE_MAX_RADIUS = 45
+
+# Feromon Ayarları
+PHEROMONE_RESOLUTION = 15
+GRID_WIDTH = SCREEN_WIDTH // PHEROMONE_RESOLUTION
+GRID_HEIGHT = SCREEN_HEIGHT // PHEROMONE_RESOLUTION
+PHEROMONE_MAX_STRENGTH = 1.0
+PHEROMONE_DEPOSIT_VALUE = 0.9
+PHEROMONE_EVAPORATION_RATE = 0.010
+PHEROMONE_DIFFUSION_RATE = 0.05
+
+# --- NN Girdi/Çıktı Ayarları (V3 ile aynı, şimdilik) ---
+# Dikkat: Bu değerler neat_config_v4.txt içindeki num_inputs ile eşleşmeli!
+# Şu anki girdiler: Home Pher (3), Food Pher (3), Bias (1), Carrying (1), Vel (2), Nest Dir (2), Food Dir (2), Food Dist (1), Agent Density (1) = 16
+num_inputs = 16 # Config dosyasıyla tutarlılık için buraya da ekleyelim (assert'te kullanılabilir)
+NN_PHEROMONE_SENSE_DIST = AGENT_SIZE * 4
+NN_PHEROMONE_SENSE_ANGLES = [-np.pi / 3, 0, np.pi / 3] # Sol, Orta, Sağ
+NN_FOOD_SENSE_RADIUS = 150
+NN_AGENT_SENSE_RADIUS = 60
+NN_OUTPUT_DEPOSIT_THRESHOLD = 0.6
+
+# --- Ko-evrim Ayarları ---
+# Fitness Hesaplama Yöntemi: 'absolute' (sadece kendi yemi), 'competitive' (kendi - rakip)
+FITNESS_METHOD = 'competitive'
+# Her genomu kaç rakip genoma karşı test edelim?
+NUM_OPPONENTS_PER_EVAL = 5
+
+# --- Görselleştirme ve Debug ---
+VISUALIZE_BEST_GENOMES = True
+VISUALIZATION_FPS = 30
+DEBUG_DRAW_PHEROMONES = False
+DEBUG_DRAW_FOOD_LOCATIONS = True
+DEBUG_DRAW_NESTS = True
+DEBUG_DRAW_OBSTACLES = True

vector.py

@@ -0,0 +1,92 @@
+# swarm_mind_v1/vector.py
+import math
+import random
+
+class Vector2D:
+    """2 Boyutlu Vektör Sınıfı."""
+    def __init__(self, x=0.0, y=0.0):
+        self.x = x
+        self.y = y
+
+    def __str__(self):
+        """Vektörün string temsilini döndürür."""
+        return f"Vector2D({self.x:.2f}, {self.y:.2f})"
+
+    def __add__(self, other):
+        """Vektör toplama (+) operatörü."""
+        return Vector2D(self.x + other.x, self.y + other.y)
+
+    def __sub__(self, other):
+        """Vektör çıkarma (-) operatörü."""
+        return Vector2D(self.x - other.x, self.y - other.y)
+
+    def __mul__(self, scalar):
+        """Skaler ile çarpma (*) operatörü."""
+        return Vector2D(self.x * scalar, self.y * scalar)
+
+    def __truediv__(self, scalar):
+        """Skaler ile bölme (/) operatörü."""
+        if scalar == 0:
+            return Vector2D() # Sıfıra bölme hatasını önle
+        return Vector2D(self.x / scalar, self.y / scalar)
+
+    def magnitude_squared(self):
+        """Vektörün büyüklüğünün karesini döndürür (sqrt daha yavaştır)."""
+        return self.x * self.x + self.y * self.y
+
+    def magnitude(self):
+        """Vektörün büyüklüğünü (uzunluğunu) döndürür."""
+        mag_sq = self.magnitude_squared()
+        if mag_sq == 0:
+            return 0.0
+        return math.sqrt(mag_sq)
+
+    def normalize(self):
+        """Vektörü birim vektöre dönüştürür (büyüklüğü 1 yapar)."""
+        mag = self.magnitude()
+        if mag > 0:
+            self.x /= mag
+            self.y /= mag
+        return self # Zincirleme için kendini döndür
+
+    def get_normalized(self):
+        """Vektörün normalize edilmiş bir kopyasını döndürür."""
+        mag = self.magnitude()
+        if mag == 0:
+            return Vector2D()
+        return Vector2D(self.x / mag, self.y / mag)
+
+    def limit(self, max_magnitude):
+        """Vektörün büyüklüğünü verilen maksimum değerle sınırlar."""
+        if self.magnitude_squared() > max_magnitude * max_magnitude:
+            self.normalize()
+            self.x *= max_magnitude
+            self.y *= max_magnitude
+        return self # Zincirleme için kendini döndür
+
+    def distance_squared(self, other):
+        """İki vektör arasındaki mesafenin karesini döndürür."""
+        dx = self.x - other.x
+        dy = self.y - other.y
+        return dx * dx + dy * dy
+
+    def distance(self, other):
+        """İki vektör arasındaki mesafeyi döndürür."""
+        return math.sqrt(self.distance_squared(other))
+
+    def set_magnitude(self, magnitude):
+        """Vektörün büyüklüğünü ayarlar."""
+        self.normalize()
+        self.x *= magnitude
+        self.y *= magnitude
+        return self
+
+    def heading(self):
+        """Vektörün açısını (radyan cinsinden) döndürür."""
+        return math.atan2(self.y, self.x)
+
+    @staticmethod
+    def random_vector():
+        """Rastgele bir yönü olan birim vektör oluşturur."""
+        angle = random.uniform(0, 2 * math.pi)
+        return Vector2D(math.cos(angle), math.sin(angle))