app.py

import gradio as gr
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import plotly.graph_objects as go
import random
import time

# Генератор процедурной вселенной
class UniverseGenerator:
    def __init__(self):
        self.galaxy_map = {}
        self.planet_types = ['Lava', 'Ocean', 'Desert', 'Ice', 'Jungle', 'Toxic', 'Radioactive']
        self.star_classes = ['O', 'B', 'A', 'F', 'G', 'K', 'M']
        self.resources = ['Titanium', 'Quartz', 'Hydrogen', 'Neutronium', 'Exotic Matter']
    
    def generate_system(self, seed):
        random.seed(seed)
        system = {
            'name': f"{random.choice(self.star_classes)}-{random.randint(1000,9999)}",
            'planets': [],
            'position': (random.uniform(-100,100), random.uniform(-100,100), random.uniform(-100,100))
        }
        
        num_planets = random.randint(3, 8)
        for i in range(num_planets):
            planet_type = random.choice(self.planet_types)
            planet = {
                'name': f"{system['name']}-{chr(97+i)}",
                'type': planet_type,
                'resources': random.sample(self.resources, random.randint(1, 3)),
                'fauna': random.randint(0, 15),
                'flora': random.randint(0, 15),
                'temperature': random.uniform(-200, 500),
                'gravity': random.uniform(0.2, 2.5),
                'size': random.uniform(0.5, 2.0)
            }
            system['planets'].append(planet)
        
        return system

    def generate_galaxy(self, num_systems=100):
        for i in range(num_systems):
            self.galaxy_map[f"System-{i}"] = self.generate_system(i)
        return self.galaxy_map

# Игровой движок
class WebspaceEngine:
    def __init__(self):
        self.universe = UniverseGenerator()
        self.galaxy = self.universe.generate_galaxy()
        self.player = {
            'position': (0, 0, 0),
            'current_system': 'System-0',
            'resources': {'Titanium': 10, 'Quartz': 5},
            'ship': 'Explorer-class',
            'credits': 1000
        }
        self.discovered_systems = ['System-0']
    
    def travel_to_system(self, system_name):
        if system_name in self.galaxy:
            self.player['current_system'] = system_name
            if system_name not in self.discovered_systems:
                self.discovered_systems.append(system_name)
            return self.galaxy[system_name]
        return None
    
    def scan_planet(self, planet_index):
        system = self.galaxy[self.player['current_system']]
        if 0 <= planet_index < len(system['planets']):
            return system['planets'][planet_index]
        return None
    
    def mine_resources(self, planet_index, resource):
        planet = self.scan_planet(planet_index)
        if planet and resource in planet['resources']:
            amount = random.randint(1, 5)
            self.player['resources'][resource] = self.player['resources'].get(resource, 0) + amount
            return f"Mined {amount} units of {resource}"
        return "Resource not found"

# Графические функции
def create_galaxy_map(discovered_systems, galaxy_map):
    fig = go.Figure()
    
    for sys_name in discovered_systems:
        system = galaxy_map[sys_name]
        x, y, z = system['position']
        
        # Звезда
        fig.add_trace(go.Scatter3d(
            x=[x], y=[y], z=[z],
            mode='markers',
            marker=dict(size=8, color='yellow'),
            name=sys_name
        ))
        
        # Планеты
        for planet in system['planets']:
            px = x + random.uniform(-3, 3)
            py = y + random.uniform(-3, 3)
            pz = z + random.uniform(-3, 3)
            
            colors = {
                'Lava': 'red',
                'Ocean': 'blue',
                'Desert': 'orange',
                'Ice': 'lightblue',
                'Jungle': 'green',
                'Toxic': 'purple',
                'Radioactive': 'greenyellow'
            }
            
            fig.add_trace(go.Scatter3d(
                x=[px], y=[py], z=[pz],
                mode='markers',
                marker=dict(size=4, color=colors.get(planet['type'], 'gray')),
                name=planet['name']
            ))
    
    fig.update_layout(
        scene=dict(
            xaxis=dict(title='X'),
            yaxis=dict(title='Y'),
            zaxis=dict(title='Z')
        ),
        margin=dict(l=0, r=0, b=0, t=0),
        height=500
    )
    return fig

def create_planet_surface(planet_type):
    size = 100
    terrain = np.zeros((size, size))
    
    # Генерация процедурного ландшафта
    for i in range(size):
        for j in range(size):
            terrain[i][j] = (
    np.sin(i/5) +
    np.cos(j/7) +
    np.sin(np.sqrt((i - size/2)**2 + (j - size/2)**2)/3)
)
    # Цветовые схемы для разных планет
    colormaps = {
        'Lava': ['black', 'darkred', 'red', 'orange'],
        'Ocean': ['darkblue', 'blue', 'cyan', 'white'],
        'Desert': ['saddlebrown', 'sandybrown', 'wheat', 'white'],
        'Ice': ['darkblue', 'lightblue', 'cyan', 'white'],
        'Jungle': ['darkgreen', 'green', 'lightgreen', 'yellow'],
        'Toxic': ['darkgreen', 'purple', 'fuchsia', 'pink'],
        'Radioactive': ['darkgreen', 'green', 'greenyellow', 'yellow']
    }
    
    cmap = LinearSegmentedColormap.from_list("custom", colormaps.get(planet_type, ['gray']), N=256)
    
    fig, ax = plt.subplots(figsize=(8, 8))
    ax.imshow(terrain, cmap=cmap)
    ax.axis('off')
    plt.tight_layout()
    return fig

# Инициализация движка
engine = WebspaceEngine()

# Gradio интерфейс
with gr.Blocks(title="Webspace Network") as demo:
    gr.Markdown("# 🚀 Webspace Network")
    gr.Markdown("### Cosmic Exploration Simulator (No Man's Sky inspired)")
    
    with gr.Row():
        with gr.Column(scale=1):
            current_system = gr.Textbox(label="Current System", value=engine.player['current_system'])
            system_info = gr.JSON(label="System Data")
            
            planet_index = gr.Slider(0, 7, step=1, label="Planet Index")
            scan_btn = gr.Button("🛰️ Scan Planet")
            planet_info = gr.JSON(label="Planet Data")
            
            resource_select = gr.Dropdown(engine.universe.resources, label="Resource to Mine")
            mine_btn = gr.Button("⛏️ Mine Resource")
            mine_result = gr.Textbox(label="Mining Result")
            
            travel_target = gr.Dropdown(list(engine.galaxy.keys()), label="Select System")
            travel_btn = gr.Button("🌌 Hyperjump")
            
            player_resources = gr.JSON(label="Your Resources", value=engine.player['resources'])
        
        with gr.Column(scale=2):
            galaxy_map = gr.Plot(label="Galaxy Map")
            planet_view = gr.Plot(label="Planet Surface")
    
    # Обновление карты галактики
    def update_galaxy_map():
        return create_galaxy_map(engine.discovered_systems, engine.galaxy)
    
    # Обновление информации о системе
    def update_system_info():
        system = engine.galaxy[engine.player['current_system']]
        return {
            "Name": system['name'],
            "Position": [round(x, 2) for x in system['position']],
            "Planets": len(system['planets'])
        }
    
    # Сканирование планеты
    def scan_planet(idx):
        planet = engine.scan_planet(int(idx))
        if planet:
            fig = create_planet_surface(planet['type'])
            return planet, fig
        return {}, None
    
    # Добыча ресурсов
    def mine_resource(resource, idx):
        result = engine.mine_resources(int(idx), resource)
        return result, engine.player['resources']
    
    # Путешествие между системами
    def travel_to_system(system):
        engine.travel_to_system(system)
        return {
            "current_system": system,
            "system_info": update_system_info(),
            "galaxy_map": update_galaxy_map()
        }
    
    # Привязка событий
    demo.load(
        fn=update_galaxy_map,
        outputs=galaxy_map
    )
    
    demo.load(
        fn=update_system_info,
        outputs=system_info
    )
    
    scan_btn.click(
        fn=scan_planet,
        inputs=planet_index,
        outputs=[planet_info, planet_view]
    )
    
    mine_btn.click(
        fn=mine_resource,
        inputs=[resource_select, planet_index],
        outputs=[mine_result, player_resources]
    )
    
    travel_btn.click(
        fn=travel_to_system,
        inputs=travel_target,
        outputs=[current_system, system_info, galaxy_map]
    )
    
    current_system.change(
        fn=update_system_info,
        outputs=system_info
    )

# Запуск приложения
if __name__ == "__main__":
    demo.launch()