Update alien_system.py

alien_system.py

@@ -1,42 +1,391 @@
----
-title: AVOLD Engine
-emoji: ✈️
-colorFrom: indigo
-colorTo: blue
-sdk: gradio
-sdk_version: 4.36.1
-python_version: "3.10"
-app_file: app.py
-pinned: false
-fullWidth: true
-short_description: টাইমার-ভিত্তিক RNG + এলিয়েন স্পনিং সিস্টেম
-tags:
-  - aviator
-  - rng
-  - alien
-  - game-engine
-  - simulation
-disable_embedding: false
----
-
-# ✈️ AVOLD ENGINE - টাইমার-ভিত্তিক RNG + এলিয়েন স্পনিং সিস্টেম
-
-## 📋 **ওভারভিউ**
-এই ইঞ্জিনটি PDF-এ বর্ণিত 6522 VIA টাইমার-ভিত্তিক র‍্যান্ডম নম্বর জেনারেটর এবং এলিয়েন স্পনিং সিস্টেমের Python ইমপ্লিমেন্টেশন।
-
-## 🎯 **মূল বৈশিষ্ট্য**
-
-### 🔢 **টাইমার-ভিত্তিক RNG সিস্টেম**
-- হার্ডওয়্যার টাইমার ইমুলেশন (১ মিলিয়ন Hz)
-- র‍্যান্ডম বাফার (SetRandomNumber/NextRandomNumber)
-- বাফার মনিটরিং ও স্বাস্থ্য পরীক্ষা
-- থ্রেড-সেফ অপারেশন
-
-### 👾 **এলিয়েন স্পনিং সিস্টেম**
-- এলোমেলো স্পন পজিশন (RNG ব্যবহার করে)
-- ডিটারমিনিস্টিক এলিয়েন আচরণ (PDF অনুযায়ী)
-- ৪ টি এলিয়েন টাইপ (Scout, Fighter, Bomber, Boss)
-- ৬ টি বিহেভিয়ার প্যাটার্ন (Dive, Circle, Straight, Zigzag, Follow, Random)
-- প্যাটার্ন সাইকেলিং
-
-## 🧠 **সিস্টেম আর্কিটেকচার**
+import json
+import os
+import random
+from dataclasses import dataclass, asdict
+from typing import List, Dict, Optional, Tuple
+from enum import Enum
+import math
+from datetime import datetime
+
+from rng_system import get_rng
+
+class AlienType(Enum):
+    """এলিয়েনের ধরণ"""
+    SCOUT = "scout"        # ছোট, দ্রুত
+    FIGHTER = "fighter"    # মাঝারি, স্ট্যান্ডার্ড
+    BOMBER = "bomber"      # বড়, ধীর
+    BOSS = "boss"          # খুব বড়, শক্তিশালী
+
+class AlienBehavior(Enum):
+    """এলিয়েনের আচরণের ধরণ (ডিটারমিনিস্টিক)"""
+    DIVE = "dive"           # ডাইভ অ্যাটাক
+    CIRCLE = "circle"       # বৃত্তাকার পথ
+    STRAIGHT = "straight"   # সরলরেখা
+    ZIGZAG = "zigzag"       # জিগজ্যাগ
+    FOLLOW = "follow"       # প্লেয়ার ফলো
+    RANDOM = "random"       # এলোমেলো (র‍্যান্ডম)
+
+@dataclass
+class AlienPattern:
+    """এলিয়েন আক্রমণের প্যাটার্ন (ডিটারমিনিস্টিক)"""
+    behavior: AlienBehavior
+    speed: float
+    amplitude: float  # জিগজ্যাগ/সার্কেলের জন্য
+    frequency: float  # জিগজ্যাগের ফ্রিকোয়েন্সি
+    duration: float   # প্যাটার্ন চলার সময়
+    next_pattern: Optional['AlienPattern'] = None
+
+@dataclass
+class Alien:
+    """এলিয়েন অবজেক্ট"""
+    id: int
+    type: AlienType
+    x: float
+    y: float
+    health: int
+    pattern: AlienPattern
+    pattern_start_time: float
+    speed_multiplier: float
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'type': self.type.value,
+            'x': round(self.x, 2),
+            'y': round(self.y, 2),
+            'health': self.health,
+            'pattern': self.pattern.behavior.value
+        }
+
+@dataclass
+class SpawnEvent:
+    """স্পন ইভেন্ট"""
+    time: float
+    alien_type: AlienType
+    x: float
+    y: float
+    pattern: AlienPattern
+
+
+class AlienPatternLibrary:
+    """
+    এলিয়েন প্যাটার্ন লাইব্রেরি - ডিটারমিনিস্টিক প্যাটার্নের সেট
+    PDF অনুযায়ী: এলিয়েনরা ডিটারমিনিস্টিক, র‍্যান্ডম নয়
+    """
+    
+    def __init__(self, patterns_file: str = "data/alien_patterns.json"):
+        self.patterns_file = patterns_file
+        self.patterns: Dict[AlienType, List[AlienPattern]] = {}
+        self._load_patterns()
+    
+    def _load_patterns(self):
+        """প্যাটার্ন লোড করা"""
+        if os.path.exists(self.patterns_file):
+            with open(self.patterns_file, 'r') as f:
+                data = json.load(f)
+                for alien_type, patterns in data.items():
+                    self.patterns[AlienType(alien_type)] = [
+                        AlienPattern(**p) for p in patterns
+                    ]
+        else:
+            # ডিফল্ট প্যাটার্ন তৈরি
+            self._create_default_patterns()
+    
+    def _create_default_patterns(self):
+        """ডিফল্ট প্যাটার্ন তৈরি (PDF-এর মতো)"""
+        
+        # Scout এলিয়েনের প্যাটার্ন
+        self.patterns[AlienType.SCOUT] = [
+            AlienPattern(AlienBehavior.DIVE, 5.0, 0, 0, 2.0),
+            AlienPattern(AlienBehavior.STRAIGHT, 4.0, 0, 0, 1.5),
+            AlienPattern(AlienBehavior.CIRCLE, 3.0, 50, 1, 3.0),
+            AlienPattern(AlienBehavior.ZIGZAG, 4.5, 30, 2, 2.5)
+        ]
+        
+        # Fighter এলিয়েনের প্যাটার্ন
+        self.patterns[AlienType.FIGHTER] = [
+            AlienPattern(AlienBehavior.FOLLOW, 3.5, 0, 0, 3.0),
+            AlienPattern(AlienBehavior.DIVE, 4.0, 0, 0, 2.5),
+            AlienPattern(AlienBehavior.STRAIGHT, 3.0, 0, 0, 2.0),
+            AlienPattern(AlienBehavior.ZIGZAG, 3.5, 40, 1.5, 3.0)
+        ]
+        
+        # Bomber এলিয়েনের প্যাটার্ন
+        self.patterns[AlienType.BOMBER] = [
+            AlienPattern(AlienBehavior.STRAIGHT, 2.0, 0, 0, 4.0),
+            AlienPattern(AlienBehavior.CIRCLE, 1.8, 80, 0.5, 5.0),
+            AlienPattern(AlienBehavior.FOLLOW, 2.2, 0, 0, 3.5)
+        ]
+        
+        # Boss এলিয়েনের প্যাটার্ন
+        self.patterns[AlienType.BOSS] = [
+            AlienPattern(AlienBehavior.CIRCLE, 1.5, 100, 0.3, 8.0),
+            AlienPattern(AlienBehavior.FOLLOW, 2.0, 0, 0, 5.0),
+            AlienPattern(AlienBehavior.DIVE, 2.5, 0, 0, 4.0),
+            AlienPattern(AlienBehavior.STRAIGHT, 1.8, 0, 0, 6.0)
+        ]
+    
+    def get_pattern_cycle(self, alien_type: AlienType) -> List[AlienPattern]:
+        """একটি এলিয়েনের জন্য প্যাটার্ন সাইকেল রিটার্ন করে"""
+        return self.patterns.get(alien_type, self.patterns[AlienType.FIGHTER])
+
+
+class AlienSpawner:
+    """
+    এলিয়েন স্পনার - PDF-এর SpawnAlien রুটিনের ইমপ্লিমেন্টেশন
+    র‍্যান্ডম অবস্থান তৈরি করতে RNG ব্যবহার করে, কিন্তু এলিয়েনের আচরণ ডিটারমিনিস্টিক
+    """
+    
+    def __init__(self, pattern_library: AlienPatternLibrary, 
+                 screen_width: int = 800, screen_height: int = 600):
+        self.rng = get_rng()
+        self.pattern_library = pattern_library
+        self.screen_width = screen_width
+        self.screen_height = screen_height
+        
+        self.aliens: List[Alien] = []
+        self.spawn_history: List[SpawnEvent] = []
+        self.next_alien_id = 0
+        
+        # স্পন প্যারামিটার
+        self.spawn_rate = 0.5  # প্রতি সেকেন্ডে এলিয়েন
+        self.last_spawn_time = time.time()
+        self.max_aliens = 20
+        
+        # স্ট্যাটিস্টিক্স
+        self.total_spawned = 0
+        self.total_killed = 0
+    
+    def _get_random_spawn_position(self) -> Tuple[float, float]:
+        """
+        এলোমেলো স্পন অবস্থান (র‍্যান্ডম - PDF অনুযায়ী)
+        """
+        side = self.rng.next_random_range(0, 3)  # 0=উপরে, 1=নিচে, 2=বামে, 3=ডানে
+        
+        if side == 0:  # উপরে
+            x = self.rng.next_random_float(0, self.screen_width)
+            y = -50
+        elif side == 1:  # নিচে
+            x = self.rng.next_random_float(0, self.screen_width)
+            y = self.screen_height + 50
+        elif side == 2:  # বামে
+            x = -50
+            y = self.rng.next_random_float(0, self.screen_height)
+        else:  # ডানে
+            x = self.screen_width + 50
+            y = self.rng.next_random_float(0, self.screen_height)
+        
+        return x, y
+    
+    def _select_alien_type(self) -> AlienType:
+        """
+        এলোমেলো এলিয়েন টাইপ সিলেক্ট (র‍্যান্ডম)
+        """
+        r = self.rng.next_random_float()
+        if r < 0.5:  # ৫০% scout
+            return AlienType.SCOUT
+        elif r < 0.8:  # ৩০% fighter
+            return AlienType.FIGHTER
+        elif r < 0.95:  # ১৫% bomber
+            return AlienType.BOMBER
+        else:  # ৫% boss
+            return AlienType.BOSS
+    
+    def _create_alien(self, alien_type: AlienType, x: float, y: float) -> Alien:
+        """
+        নতুন এলিয়েন তৈরি
+        """
+        # এলিয়েন টাইপ অনুযায়ী স্বাস্থ্য
+        health_map = {
+            AlienType.SCOUT: 1,
+            AlienType.FIGHTER: 3,
+            AlienType.BOMBER: 5,
+            AlienType.BOSS: 20
+        }
+        
+        # প্যাটার্ন সাইকেল থেকে প্রথম প্যাটার্ন নেওয়া
+        patterns = self.pattern_library.get_pattern_cycle(alien_type)
+        pattern = patterns[0]
+        
+        # স্পিড মাল্টিপ্লায়ার (ছোট ভ্যারিয়েশন)
+        speed_multiplier = 0.9 + self.rng.next_random_float() * 0.2
+        
+        alien = Alien(
+            id=self.next_alien_id,
+            type=alien_type,
+            x=x,
+            y=y,
+            health=health_map[alien_type],
+            pattern=pattern,
+            pattern_start_time=time.time(),
+            speed_multiplier=speed_multiplier
+        )
+        
+        self.next_alien_id += 1
+        return alien
+    
+    def update(self, dt: float, player_x: float = 400, player_y: float = 300):
+        """
+        প্রতি ফ্রেমে আপডেট
+        """
+        current_time = time.time()
+        
+        # নতুন এলিয়েন স্পন
+        if (len(self.aliens) < self.max_aliens and 
+            current_time - self.last_spawn_time > 1.0 / self.spawn_rate):
+            
+            alien_type = self._select_alien_type()
+            x, y = self._get_random_spawn_position()
+            alien = self._create_alien(alien_type, x, y)
+            
+            self.aliens.append(alien)
+            self.spawn_history.append(SpawnEvent(
+                time=current_time,
+                alien_type=alien_type,
+                x=x,
+                y=y,
+                pattern=alien.pattern
+            ))
+            self.total_spawned += 1
+            self.last_spawn_time = current_time
+        
+        # এলিয়েনদের অবস্থান আপডেট (ডিটারমিনিস্টিক প্যাটার্ন অনুযায়ী)
+        aliens_to_remove = []
+        for alien in self.aliens:
+            self._update_alien_position(alien, dt, player_x, player_y)
+            
+            # স্ক্রিনের বাইরে চলে গেলে রিমুভ
+            if (alien.x < -200 or alien.x > self.screen_width + 200 or
+                alien.y < -200 or alien.y > self.screen_height + 200):
+                aliens_to_remove.append(alien)
+        
+        # মৃত এলিয়েন রিমুভ
+        for alien in aliens_to_remove:
+            if alien in self.aliens:
+                self.aliens.remove(alien)
+                self.total_killed += 1
+    
+    def _update_alien_position(self, alien: Alien, dt: float, 
+                                player_x: float, player_y: float):
+        """
+        এলিয়েনের অবস্থান আপডেট (প্যাটার্ন অনুযায়ী - ডিটারমিনিস্টিক)
+        """
+        time_in_pattern = time.time() - alien.pattern_start_time
+        
+        # প্যাটার্নের সময় শেষ হলে পরবর্তী প্যাটার্নে যাওয়া
+        if time_in_pattern > alien.pattern.duration:
+            patterns = self.pattern_library.get_pattern_cycle(alien.type)
+            current_index = patterns.index(alien.pattern) if alien.pattern in patterns else 0
+            next_index = (current_index + 1) % len(patterns)
+            alien.pattern = patterns[next_index]
+            alien.pattern_start_time = time.time()
+            time_in_pattern = 0
+        
+        speed = alien.pattern.speed * alien.speed_multiplier * dt * 60  # 60 FPS ধরে
+        
+        # প্যাটার্ন অনুযায়ী মুভমেন্ট
+        if alien.pattern.behavior == AlienBehavior.DIVE:
+            # প্লেয়ারের দিকে ডাইভ
+            dx = player_x - alien.x
+            dy = player_y - alien.y
+            dist = math.sqrt(dx*dx + dy*dy)
+            if dist > 0:
+                alien.x += (dx / dist) * speed
+                alien.y += (dy / dist) * speed
+        
+        elif alien.pattern.behavior == AlienBehavior.CIRCLE:
+            # বৃত্তাকার পথ
+            angle = time_in_pattern * alien.pattern.frequency
+            alien.x += math.cos(angle) * speed
+            alien.y += math.sin(angle) * speed
+        
+        elif alien.pattern.behavior == AlienBehavior.STRAIGHT:
+            # সরলরেখায় (পূর্ব নির্ধারিত দিকে)
+            alien.x -= speed  # বামে
+        
+        elif alien.pattern.behavior == AlienBehavior.ZIGZAG:
+            # জিগজ্যাগ প্যাটার্ন
+            alien.x -= speed
+            alien.y += math.sin(time_in_pattern * alien.pattern.frequency) * alien.pattern.amplitude * dt
+        
+        elif alien.pattern.behavior == AlienBehavior.FOLLOW:
+            # প্লেয়ারকে ফলো
+            dx = player_x - alien.x
+            dy = player_y - alien.y
+            dist = math.sqrt(dx*dx + dy*dy)
+            if dist > 100:  # ১০০ পিক্সেল দূরত্বে রাখে
+                if dist > 0:
+                    alien.x += (dx / dist) * speed * 0.5
+                    alien.y += (dy / dist) * speed * 0.5
+        
+        # র‍্যান্ডম বিহেভিয়ার (শুধু যদি সেট করা থাকে)
+        elif alien.pattern.behavior == AlienBehavior.RANDOM:
+            alien.x += (self.rng.next_random_float() - 0.5) * speed * 2
+            alien.y += (self.rng.next_random_float() - 0.5) * speed * 2
+    
+    def damage_alien(self, alien_id: int, damage: int = 1) -> bool:
+        """এলিয়েনকে আঘাত করা"""
+        for alien in self.aliens:
+            if alien.id == alien_id:
+                alien.health -= damage
+                if alien.health <= 0:
+                    self.aliens.remove(alien)
+                    self.total_killed += 1
+                    return True
+                break
+        return False
+    
+    def get_aliens_data(self) -> List[dict]:
+        """UI-এর জন্য এলিয়েন ডাটা"""
+        return [alien.to_dict() for alien in self.aliens]
+    
+    def get_stats(self) -> dict:
+        """পরিসংখ্যান"""
+        return {
+            'total_spawned': self.total_spawned,
+            'total_killed': self.total_killed,
+            'active_aliens': len(self.aliens),
+            'spawn_rate': self.spawn_rate
+        }
+    
+    def get_spawn_history(self, limit: int = 50) -> List[dict]:
+        """স্পন হিস্ট্রি"""
+        return [
+            {
+                'time': datetime.fromtimestamp(e.time).strftime('%H:%M:%S'),
+                'type': e.alien_type.value,
+                'position': f"({int(e.x)},{int(e.y)})"
+            }
+            for e in self.spawn_history[-limit:]
+        ]
+
+
+class AlienAIManager:
+    """
+    এলিয়েন এআই ম্যানেজার - ডিটারমিনিস্টিক প্যাটার্ন ম্যানেজ করে
+    PDF অনুযায়ী: এলিয়েনরা ডিটারমিনিস্টিক
+    """
+    
+    def __init__(self):
+        self.pattern_library = AlienPatternLibrary()
+        self.current_cycle_index = 0
+        self.cycle_length = 4  # প্রতি ৪ রাউন্ডে প্যাটার্ন রিসেট
+        
+    def get_attack_wave_pattern(self, wave_number: int) -> List[AlienPattern]:
+        """
+        ওয়েব নম্বর অনুযায়ী অ্যাটাক প্যাটার্ন
+        ডিটারমিনিস্টিক - প্রতি ওয়েভে একই প্যাটার্ন রিপিট
+        """
+        base_pattern = self.pattern_library.get_pattern_cycle(AlienType.FIGHTER)
+        
+        # ওয়েব নম্বর অনুযায়ী প্যাটার্ন মডিফাই
+        wave_index = (wave_number // self.cycle_length) % len(base_pattern)
+        
+        return [base_pattern[wave_index]]
+    
+    def predict_next_attack(self, current_wave: int) -> str:
+        """
+        পরবর্তী অ্যাটাকের ধরণ প্রেডিক্ট (ডিটারমিনিস্টিক)
+        """
+        next_pattern = self.get_attack_wave_pattern(current_wave + 1)
+        return f"পরবর্তী অ্যাটাক: {next_pattern[0].behavior.value}"