Star Aristocracy

"""
Star Aristocracy - Autonomous Rover Navigation Brain v0.2
Born Again Technologies Division
Simulates rover decision-making with obstacle detection and pathfinding
"""

import random
import math
import csv
import time
from datetime import datetime

class RoverBrain:
    def __init__(self, grid_size=20, start=(0, 0), goal=(19, 19)):
        self.grid_size = grid_size
        self.position = list(start)
        self.goal = goal
        self.heading = 0  # degrees, 0=North
        self.speed = 0.0  # m/s
        self.obstacles = self._generate_obstacles()
        self.telemetry_log = []
        self.battery = 100.0
        
    def _generate_obstacles(self):
        """Generate random obstacle positions"""
        obstacles = set()
        for _ in range(30):
            x = random.randint(0, self.grid_size - 1)
            y = random.randint(0, self.grid_size - 1)
            obstacles.add((x, y))
        return obstacles
    
    def scan_surroundings(self):
        """Simulate LIDAR/sensor scan in 8 directions"""
        directions = [
            (-1, 0), (1, 0), (0, -1), (0, 1),  # N, S, W, E
            (-1, -1), (-1, 1), (1, -1), (1, 1)  # Diagonals
        ]
        obstacles_detected = []
        for dx, dy in directions:
            check_x = self.position[0] + dx
            check_y = self.position[1] + dy
            if (check_x, check_y) in self.obstacles:
                obstacles_detected.append((dx, dy))
        return obstacles_detected
    
    def calculate_next_move(self, obstacles_nearby):
        """Simple pathfinding: move toward goal while avoiding obstacles"""
        goal_vector = (self.goal[0] - self.position[0], 
                       self.goal[1] - self.position[1])
        
        # Normalize possible moves
        moves = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        best_move = None
        best_score = -999999
        
        for move in moves:
            next_pos = (self.position[0] + move[0], self.position[1] + move[1])
            
            # Skip if out of bounds or obstacle
            if (next_pos[0] < 0 or next_pos[0] >= self.grid_size or
                next_pos[1] < 0 or next_pos[1] >= self.grid_size or
                next_pos in self.obstacles):
                continue
            
            # Score: distance to goal (lower is better)
            dist = math.sqrt((next_pos[0] - self.goal[0])**2 + 
                           (next_pos[1] - self.goal[1])**2)
            score = -dist
            
            if score > best_score:
                best_score = score
                best_move = move
        
        return best_move
    
    def move(self, direction):
        """Execute movement and update telemetry"""
        if direction is None:
            self.speed = 0
            return False
        
        self.position[0] += direction[0]
        self.position[1] += direction[1]
        self.speed = 0.5  # m/s
        self.battery -= 0.2
        
        # Log telemetry
        self.telemetry_log.append({
            'timestamp': datetime.now().isoformat(),
            'x': self.position[0],
            'y': self.position[1],
            'speed': self.speed,
            'battery': round(self.battery, 2),
            'distance_to_goal': round(math.sqrt(
                (self.position[0] - self.goal[0])**2 + 
                (self.position[1] - self.goal[1])**2
            ), 2)
        })
        return True
    
    def at_goal(self):
        """Check if rover reached destination"""
        return tuple(self.position) == self.goal
    
    def save_telemetry(self, filename='rover_telemetry.csv'):
        """Export telemetry to CSV"""
        if not self.telemetry_log:
            return
        
        keys = self.telemetry_log[0].keys()
        with open(filename, 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=keys)
            writer.writeheader()
            writer.writerows(self.telemetry_log)
        print(f"[ROVER] Telemetry saved to {filename}")

def main():
    print("=" * 50)
    print("STAR ARISTOCRACY - ROVER NAVIGATION BRAIN v0.2")
    print("=" * 50)
    
    rover = RoverBrain()
    step = 0
    max_steps = 100
    
    print(f"Mission: Navigate from {rover.position} to {rover.goal}")
    print(f"Obstacles detected: {len(rover.obstacles)}")
    print()
    
    while step < max_steps and not rover.at_goal() and rover.battery > 0:
        obstacles = rover.scan_surroundings()
        next_move = rover.calculate_next_move(obstacles)
        
        if next_move is None:
            print(f"[STEP {step}] BLOCKED - No safe path available")
            break
        
        rover.move(next_move)
        
        if step % 10 == 0:
            print(f"[STEP {step}] Position: {rover.position}, "
                  f"Battery: {rover.battery:.1f}%, "
                  f"Distance: {rover.telemetry_log[-1]['distance_to_goal']:.1f}m")
        
        step += 1
        time.sleep(0.05)  # Simulate processing delay
    
    print()
    if rover.at_goal():
        print(f"✓ MISSION SUCCESS - Goal reached in {step} steps")
    elif rover.battery <= 0:
        print("✗ MISSION FAILED - Battery depleted")
    else:
        print("✗ MISSION FAILED - Path blocked or timeout")
    
    rover.save_telemetry()
    print(f"Final position: {rover.position}")
    print(f"Battery remaining: {rover.battery:.1f}%")

if __name__ == "__main__":
    main()