LF
LUCIDA-FLOW v2.0 DOCS
RELEASE v2.0 STABLE Windows (.exe / .msix) & macOS (.app) MarcoDB + Quantum Engine Embedded

Manual Oficial e Referência da Linguagem Lucida-Flow v2.0

Guia completo de engenharia de software, simulação quântica Statevector, projeção gráfica 3D, interfaces desktop nativas e banco de dados multimodelo MarcoDB. Projetado pela QOrigin / SoteroApps para estudantes, pesquisadores e arquitetos de sistemas.

Paradigma
Fluxo + POO + Funcional
Sistema de Tipos
Estático / Gradual (AST)
Módulos Nativos
11 Bibliotecas Core
Compilador
Standalone .EXE / .APP

LUCIDA-FLOW STUDIO // SIMULADOR INTERATIVO DE PROTOCOLOS

protocolo_ativo.lf ● Interpretador Live: Edite e pressione F5
SAÍDA DO CONSOLE REPL & TELEMETRIA VISUAL PRONTO

                        
                        
CANVAS 2D/3D PREVIEW (Arraste ou edite ângulos) Esfera de Bloch 3D
VOLUME I

1. Fundamentos, Léxico, Tipagem e Operadores

Arquitetura do compilador de 4 estágios, atalhos do Studio IDE, literais numéricos, F-Strings, desestruturação e tabela de precedência de 16 níveis.

1.1 Pipeline de Execução de 4 Estágios, Compilador Standalone & Studio IDE

Diferente de linguagens puramente interpretadas linha a linha sem validação prévia, a Lucida-Flow v2.0 submete todo protocolo (.lf) a uma cadeia estática e semântica antes de executar a primeira instrução ou empacotar um executável nativo:

1. Lexer (Léxico)

Tokeniza o código-fonte rastreando linha e coluna exatas (L:C) e processa literais em múltiplas bases e F-Strings.

2. Parser (AST)

Constrói a Árvore Sintática Abstrata e expande operadores v2 como Pipe (|>) e atribuições compostas (+=).

3. SemanticAnalyzer

Valida escopos (ScopedSymbolTable), tipos estáticos, proteção de const, herança de classes e assinaturas de módulos.

4. Interpreter / EXE

Executa a AST via CallStack / ActivationRecord ou empacota em binário standalone .exe / .app.

Atalho / Comando Ação no Studio Comportamento Técnico
Ctrl + N✦ Novo ProtocoloAbre uma nova aba com realce de sintaxe e autocompletar inteligente.
Ctrl + O / Ctrl + S⇪ Carregar / ⭳ SalvarAbre ou salva arquivos .lf em UTF-8 com monitoramento de modificação (●).
F5▶ ExecutarRoda scripts de console na thread interna ou abre apps gui via processo isolado --runner.
Shift + F5🛑 Parar SistemaInterrompe imediatamente loops infinitos, leituras de input ou janelas gráficas.
⚙ Compilar (.EXE/.APP)📦 Empacotar BinárioEmpacota a AST validada + runtime e módulos nativos em executável autônomo sem dependências externas.
Ctrl + L🧹 Limpar TerminalLimpa o histórico visual do console interativo REPL.

1.2 Regras Léxicas, Comentários, Literais em Múltiplas Bases e F-Strings

Quebras de linha finalizam instruções automaticamente (o uso de ; é opcional e serve para colocar múltiplas instruções na mesma linha). Números aceitam sublinhados (_) para legibilidade e podem ser declarados em decimal, hexadecimal (0x), binário (0b), octal (0o) ou notação científica (1.5e-10).

// 1. Comentário de linha estilo C/JavaScript
#  2. Comentário de linha estilo Python/Shell
/* 3. Comentário de bloco multi-linha */

// Literais inteiros em múltiplas bases com separador '_'
let distancia_km: int = 384_400
let cor_cyberpunk: int = 0xFF_00_7F      // Hexadecimal (16711807)
let registrador_bits: int = 0b1011_0010  // Binário (178)
let permissao_unix: int = 0o755          // Octal (493)
let constante_planck: float = 6.626e-34  // Notação Científica

// F-Strings (Interpolação de expressões com f"...") e Strings Multi-linha ("""...""")
let nome = "QOrigin"
let versao = 2.0
print(f"Sistema {nome} operando na versão {versao} -> Dobro: {versao * 2}")

let mql_query = """
SELECT id, operacao, dirac
FROM telemetria
ORDER BY passo DESC LIMIT 5
"""

1.3 Sistema de Tipos, Variáveis (let), Constantes (const) e Desestruturação

A linguagem possui 9 tipos fundamentais: int, float, string, bool, list, tuple, dict, null e any. Valores int são automaticamente promovidos quando atribuídos a variáveis float.

// Variáveis mutáveis (let) com inferência ou anotação explícita
let contador = 0                   // Inferido estaticamente como 'int'
let voltagem: float = 12           // 'int' 12 promovido automaticamente para 'float' (12.0)
let payload: any = {"ok": true}    // 'any' permite trocar o tipo dinamicamente

// Constantes imutáveis (const) protegidas em tempo de compilação pelo SemanticAnalyzer
const VELOCIDADE_LUZ: float = 299_792_458.0

// Desestruturação Estrutural (Tuplas, Listas e Múltiplas Variáveis)
let coordenadas_bloch = (0.7071, 0.0, 0.7071)
let (bx, by, bz) = coordenadas_bloch
const [primeiro, segundo] = ["Alfa", "Beta"]
let largura, altura = 1920, 1080

1.4 Operadores Especiais da v2 (|>, ??, ? :) e Precedência de 16 Níveis

import "qbit" as qbit
import "math3d" as math3d

// 1. Operador Pipe Funcional (|>) -> Injeta o valor da esquerda como 1º argumento à direita
let estado = 0 |> qbit.h_gate() |> qbit.rz_gate(1.5708) |> qbit.x_gate()

let ponto_tela = [1.0, 2.0, 4.0]
    |> math3d.rotate_y(0.5)
    |> math3d.rotate_x(0.25)
    |> math3d.project_2d(340.0, 3.8, 800.0, 600.0)

// 2. Operador de Coalescência Nula (??) -> Retorna o lado direito apenas se a esquerda for null
let porta_config: any = null
let porta_final = porta_config ?? 7070   // 7070

// 3. Operador Condicional Ternário (? :)
let prob_zero = 0.85
let rotulo = prob_zero >= 0.5 ? "Estado Dominante |0>" : "Estado Dominante |1>"

// 4. Operadores de Pertinência (in / not in) e Bitwise (&, |, ^, ~, <<, >>)
let permissoes = ["leitura", "execucao"]
let tem_acesso = "leitura" in permissoes and "admin" not in permissoes
let mascara = (1 << 4) | 0b0011          // 19
Nível Operadores Descrição e Associatividade
1 (Maior)() [] [a:b:c] .Agrupamento, chamada, indexação, slicing e acesso a membro
2+x -x ~xUnários positivo, negativo e NOT bitwise
3**Exponenciação (associativo da direita para a esquerda)
4 / 5* / % | + -Multiplicação, divisão, módulo, adição e subtração
6<< >>Shift bitwise à esquerda e à direita
7== != < > <= >= in not in notComparação relacional, pertinência em coleção e negação booleana
8 / 9 / 10& | ^ | |AND bitwise (8), XOR bitwise (9) e OR bitwise (10)
11 / 12and | orE lógico (11) e OU lógico (12) com avaliação em curto-circuito
13 / 14 / 15?? | ? : | |>Coalescência nula (13), Ternário (14) e Pipe Funcional (15)
16 (Menor)= += -= *= /= **= %=Atribuição simples e atribuições compostas
VOLUME II

2. Controle de Fluxo e Pattern Matching

Desvios condicionais semânticos, correspondência de padrões avançada com guardas e laços de repetição multi-iterador.

2.1 Condicionais (when, else when, otherwise / else)

Blocos condicionais utilizam when. O ramo padrão aceita tanto otherwise quanto else:

let fidelidade_quantica = 0.985

when fidelidade_quantica >= 0.99 {
    print("Estado quântico ultra-puro.")
} else when fidelidade_quantica >= 0.90 {
    print("Fidelidade dentro da margem operacional.")
} otherwise {
    print("Alerta: Decoerência elevada detectada!")
}

2.2 Pattern Matching (match / case) com Guardas Condicionais

O match pode ser usado tanto como expressão (retornando um valor diretamente para uma variável) quanto como comando (executando blocos { ... }). Suporta múltiplos literais por ramo, captura de variável com cláusula when e curinga else / case _:

let temperatura_kelvin = 0.015

// 1. 'match' como Expressão com Guarda Condicional (case x when ...)
let regime_termico = match temperatura_kelvin {
    case 0.0 => "Zero Absoluto Teórico"
    case t when t < 0.05 => f"Criogenia Diluída ({t} K) - Pronta para Qubits"
    case t when t < 77.0 => "Hélio Líquido"
    case 273.15, 300.0 => "Temperatura Ambiente / Ponto de Fusão"
    else => "Temperatura Elevada"
}
print(regime_termico)

// 2. 'match' como Comando para despacho de eventos de teclado na GUI
let tecla = "h"
match tecla.to_lower() {
    case "h" => print("Aplicando Porta Hadamard")
    case "x", "y", "z" => {
        print(f"Aplicando Porta de Pauli: {tecla.to_upper()}")
    }
    case _ => print("Tecla não mapeada")
}

2.3 Laços while e for each (Iteração Chave-Valor, Enumeração e Tuplas)

// 1. Iteração sobre Dicionário extraindo (chave, valor) automaticamente
let modulos = {"qbit": "Computação Quântica", "marcodb": "Banco Multimodelo"}
for each sigla, descricao in modulos {
    print(f"[{sigla}] -> {descricao}")
}

// 2. Enumeração automática (índice, elemento) sobre Listas
let portas = ["Hadamard", "Pauli-X", "CNOT"]
for each idx, nome_porta in portas {
    print(f"Passo #{idx + 1}: {nome_porta}")
}

// 3. Desempacotamento direto de Lista de Tuplas 3D
let polos = [("|0>", 0.0, 0.0, 1.0), ("|1>", 0.0, 0.0, -1.0)]
for each ket, x, y, z in polos {
    print(f"Polo {ket} -> ({x}, {y}, {z})")
}
VOLUME III

3. Coleções, Fatiamento (Slicing) e Compreensões

Manipulação expressiva de Listas, Tuplas, Dicionários e Strings com slicing nativo, compreensões declarativas e catálogo de métodos embutidos.

3.1 Fatiamento Nativo [inicio:fim:passo] & Compreensões de Lista/Dicionário

Listas e strings suportam indexação negativa (-1 acessa o último elemento) e fatiamento em três parâmetros [inicio:fim:passo]. As compreensões permitem transformar e filtrar coleções em uma única expressão declarativa:

let dados = [10, 20, 30, 40, 50, 60]
print(dados[1:4])       // [20, 30, 40]
print(dados[:3])        // [10, 20, 30]
print(dados[::2])       // [10, 30, 50] (passo 2)
print(dados[::-1])      // [60, 50, 40, 30, 20, 10] (inversão rápida)

let palavra = "LUCIDA"
print(palavra[:-1])     // "LUCID" (ideal para Backspace em visores GUI!)

// List Comprehension com filtro condicional 'when'
let quadrados_pares = [x ** 2 for each x in range(1, 11) when x % 2 == 0]
// Resultado: [4, 16, 36, 64, 100]

// Dict Comprehension
let mapa_cubos = {f"n_{x}": x ** 3 for each x in range(1, 5)}
// Resultado: {"n_1": 1, "n_2": 8, "n_3": 27, "n_4": 64}

3.2 Referência Completa de Métodos Nativos (string, list, dict & Builtins)

Métodos de String (Imutáveis)
  • .to_upper() / .to_lower() — Converte caixa alta/baixa
  • .trim() — Remove espaços/quebras nas bordas
  • .split(sep = " ") -> list — Divide em lista de substrings
  • .replace(alvo, novo) -> string — Substitui todas as ocorrências
  • .contains(sub) -> bool — Verifica se contém substring
  • .starts_with(pref) / .ends_with(suf) — Valida prefixo/sufixo
  • .find(sub) -> int — Índice da 1ª ocorrência ou -1
  • .count(sub) -> int — Conta ocorrências não sobrepostas
  • .slice(ini, fim) / .length() — Recorte e tamanho
Métodos de List (Mutáveis / Dinâmicas)
  • .append(item) / .push(item) — Insere elemento no final
  • .pop([indice]) -> any — Remove e retorna item (padrão: último)
  • .insert(indice, item) — Insere deslocando os seguintes
  • .remove(valor) — Remove a 1ª ocorrência do valor
  • .index_of(valor) -> int — Posição do item ou -1
  • .contains(valor) -> bool — Verifica pertinência
  • .sort() / .reverse() — Ordena in-place / inverte ordem
  • .join(sep) -> string — Concatena itens usando separador
  • .clear() / .count(val) / .length()
Métodos de Dict (Tabelas Hash Chave-Valor)
  • .keys() -> list — Lista com todas as chaves
  • .values() -> list — Lista com todos os valores
  • .items() -> list — Lista de tuplas (chave, valor)
  • .get(chave, [padrao]) -> any — Leitura segura sem exceção
  • .has_key(chave) -> bool — Verifica existência da chave
  • .pop(chave, [padrao]) -> any — Remove chave e retorna valor
  • .clear() / .length() — Esvazia ou conta pares
Funções Globais Embutidas (Built-ins)
  • print(...args) / input([prompt]) -> string
  • len(colecao) -> int / typeof(valor) -> string
  • range([ini], fim, [passo]) -> list
  • to_int(x), to_float(x), to_string(x), to_bool(x)
  • sum(lista), min(lista), max(lista)
  • round(num, [casas]) / abs(num)
VOLUME IV

4. Processos, Lambdas, POO, Enums e Exceções

Sub-rotinas tipadas com parâmetros default, funções flecha concisas, orientação a objetos com herança e tratamento estruturado de erros.

4.1 Declaração de Processos, Fat-Arrow (=>) e Lambdas Inline

Sub-rotinas são definidas com define process, suportando anotações de tipo nos parâmetros, valores padrão opcionais, tipo de retorno explícito (-> tipo) e sintaxe reduzida Fat-Arrow (=>). Funções anônimas (Lambdas) podem ser atribuídas a variáveis ou passadas diretamente como callbacks de botões GUI:

// 1. Processo tradicional com parâmetro default/opcional e tipo de retorno
define process calcular_energia(massa: float, c: float = 299792458.0) -> float {
    return massa * (c ** 2)
}

// 2. Processos concisos de expressão única (Fat-Arrow =>)
define process hipotenusa(a: float, b: float) -> float => (a ** 2 + b ** 2) ** 0.5
define process dobrar(n: int) -> int => n * 2

// 3. Processo de evento e Lambda Anônima Inline (para callbacks)
define process logar_clique(id_botao: string) {
    print(f"[EVENTO GUI] Botão acionado: {id_botao}")
}

let callback_evento = process(id_botao: string) {
    print(f"[CALLBACK] Handler registrado para: {id_botao}")
}

print(f"Energia: {calcular_energia(0.001)}")
print(f"Hipotenusa (3, 4): {hipotenusa(3.0, 4.0)}")
print(dobrar(21)) // 42
logar_clique("btn_executar")

4.2 Programação Orientada a Objetos (define type, Herança <, self e super)

Classes são declaradas via define type NomeClasse. O construtor utiliza o nome reservado init, atributos de instância são referenciados por self.campo e a herança simples é estabelecida pelo operador < com suporte a super.metodo():

define type DispositivoQuantico {
    let nome: string = ""
    let qubits: int = 0

    define process __init__(self, nome: string, qubits: int) {
        self.nome = nome
        self.qubits = qubits
    }

    define process dimensao_hilbert(self) -> int => 2 ** self.qubits
}

// Herança usando o operador '<' e acesso aos atributos e métodos herdados via 'self'
define type ProcessadorSupercondutor < DispositivoQuantico {
    let temp_mk: float = 0.0

    define process __init__(self, nome: string, qubits: int, temp_mk: float) {
        self.nome = nome
        self.qubits = qubits
        self.temp_mk = temp_mk
    }

    define process relatorio(self) -> string {
        return f"{self.nome}: {self.qubits} qubits (Hilbert 2^{self.qubits} = {self.dimensao_hilbert()}) a {self.temp_mk} mK"
    }
}

let chip = ProcessadorSupercondutor("QOrigin-Eagle", 12, 15.0)
print(chip.relatorio())

4.3 Enumerações (define enum) e Exceções (try / catch / finally / throw)

define enum EstadoTransacao {
    PENDENTE,
    CONFIRMADA,
    REVERTIDA
}

let status_atual = EstadoTransacao.CONFIRMADA

try {
    when status_atual == EstadoTransacao.REVERTIDA {
        throw "Transação abortada pelo motor ACID."
    }
    print(f"Status validado: {status_atual}")
} catch (erro) {
    print(f"Exceção capturada: {erro}")
} finally {
    print("Auditoria de bloco concluída.")
}
VOLUME V

5. Biblioteca Padrão: Sistema, Matemática, Rede e Mídia

Referência completa de funções e constantes dos módulos nativos math, time, fs, json, web, dado e media.

5.1 Matemática Científica (math) e Cronometria de Alta Precisão (time)

Módulo "math" (import "math" as math)

Constantes: math.pi (3.14159...), math.e (2.71828...), math.tau (6.28318...), math.phi (1.61803...), math.inf
Trigonométricas & Hiperbólicas: sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), atan2(y,x), sinh(x), cosh(x), tanh(x), deg_to_rad(g), rad_to_deg(r)
Potências & Logaritmos: sqrt(x), cbrt(x), hypot(dx,dy), exp(x), ln(x), log10(x), log2(x), log(x, base)
Estatística, Álgebra & Interpolação: mean(lista), median(lista), variance(lista), std(lista), factorial(n), gcd(a,b), lcm(a,b), comb(n,k), perm(n,k), is_prime(n), bhaskara(a,b,c), linspace(ini,fim,n), clamp(x,min,max), lerp(a,b,t).

Módulo "time" / "datetime" (import "time" as time)

Relógio & Timestamps: time.now() (data/hora local), time.today(), time.iso() (ISO-8601), time.timestamp() -> float (segundos Unix), time.millis() -> int
Benchmark Científico: time.tic() (inicia cronômetro interno), time.toc() -> float (segundos decorridos), time.toc_ms() -> float (milissegundos decorridos), time.perf_counter()
Controle de Execução & Calendário: time.sleep(seg), time.sleep_ms(ms), time.format(ts, mascara), time.components() -> dict (ano, mês, dia, hora, minuto, segundo).

import "math" as math
import "time" as time

time.tic()
let raizes = math.bhaskara(1.0, -5.0, 6.0)     // [3.0, 2.0]
let amostra = math.linspace(0.0, math.pi, 5)   // 5 pontos igualmente espaçados
let desv_pad = math.std([10.0, 12.0, 23.0, 23.0, 16.0, 23.0, 21.0, 16.0])
let decorrido = time.toc_ms()
print(f"Raízes: {raizes} | Desvio Padrão: {round(desv_pad, 3)} | Tempo: {decorrido} ms")

5.2 Sistema de Arquivos (fs), Serialização (json) e Cliente HTTP (web)

Módulo "fs"

fs.read(path), fs.write(path, txt), fs.append(path, txt), fs.read_lines(path), fs.exists(path), fs.is_file(p), fs.is_dir(p), fs.mkdir(dir), fs.list_dir([dir]), fs.remove(path), fs.copy(orig, dest), fs.size(path), fs.join(...partes).

Módulo "json"

json.parse(str) -> dict/list, json.stringify(obj) -> string, json.pretty(obj, [indent]) -> string, json.load(caminho) -> any, json.save(caminho, obj) -> bool, json.is_valid(str) -> bool.

Módulo "web"

web.get(url, [headers]), web.get_json(url) -> dict, web.post_json(url, payload, [headers]), web.download(url, destino), web.ping(host) -> bool, web.url_encode(str), web.abrir_navegador(url).

import "fs" as fs
import "json" as json
import "web" as web

// Manipulação segura de arquivos e diretórios com 'fs' e 'json'
when not fs.exists("dados_telemetria") {
    fs.mkdir("dados_telemetria")
}

let caminho = fs.join("dados_telemetria", "config.json")
json.save(caminho, {"projeto": "QOrigin", "versao": 2.0, "ativo": true})

when fs.exists(caminho) {
    let cfg = json.load(caminho)
    print("Config carregada: " + json.pretty(cfg))
}

5.3 Gerador Estocástico/RPG (dado) e Sintetizador de Áudio (media)

Módulo "dado" (Estocástica & RPG)

dado.d4(), dado.d6(), dado.d8(), dado.d10(), dado.d12(), dado.d20(), dado.d100(), dado.rolar(qtd, faces, [bonus]), dado.inteiro(min, max), dado.flutuante(min, max), dado.gauss(media, desvio), dado.escolher(lista), dado.escolher_pesos(itens, pesos), dado.embaralhar(lista), dado.uuid() -> string.

Módulo "media" (Áudio & Síntese PCM)

media.tocar_tom(freq_hz, duracao_ms, [volume]) (gera onda senoidal pura em memória sem precisar de arquivos externos), media.tocar_sequencia(lista_notas), media.beep(), media.tocar_wav(caminho), media.parar_audio().

import "dado" as dado
import "media" as media

let acerto_critico = dado.d20()
let id_sessao = dado.uuid()
let loot = dado.escolher_pesos(["Comum", "Raro", "Lendário"], [70.0, 25.0, 5.0])
print(f"Sessão {id_sessao} | D20: {acerto_critico} | Item: {loot}")

// Sintetizador de ondas sonoras em tempo real (sem precisar de arquivos .wav externos!)
media.tocar_tom(440.0, 150)   // Lá (440 Hz) por 150 ms
media.beep()
VOLUME VI

6. Interfaces Gráficas Desktop e Motor 2D (gui)

Construção de aplicações desktop nativas com pilha de containers horizontais/verticais, widgets interativos e Canvas de alta taxa de quadros.

6.1 Pilha de Containers de Layout (iniciar_linha e iniciar_coluna)

O módulo gui gerencia uma pilha interna de containers (_CONTAINER_STACK). Ao chamar gui.iniciar_linha(espacamento, cor_fundo), todos os botões, entradas ou rótulos criados a seguir são posicionados lado a lado horizontalmente até que gui.encerrar_linha() seja chamado:

import "gui" as gui

gui.criar_janela("Painel de Controle QOrigin", "520x320", "#090A0F")
gui.criar_rotulo("lbl_topo", "CONTROLE DE REATOR QUÂNTICO", "#00FFFF", "#090A0F", 13)
gui.criar_separador("#1E293B")

// Fileira horizontal de botões lado a lado com Lambdas Inline
gui.iniciar_linha(10, "#090A0F")
    gui.criar_botao("b1", "⚡ Iniciar", process() { gui.alterar_texto("lbl_topo", "REATOR ONLINE") }, "#FF007F", "#FFFFFF")
    gui.criar_botao("b2", "❄️ Resfriar", process() { gui.alterar_texto("lbl_topo", "CRIOGENIA ATIVA") }, "#1E293B", "#00FFFF")
    gui.criar_botao("b3", "🛑 Parar", process() { gui.fechar_janela() }, "#1E293B", "#39FF14")
gui.encerrar_linha()

gui.iniciar_loop()

6.2 Catálogo Completo de Funções do Módulo gui

Categoria Assinatura da Função Descrição Técnica
Janela & Loopgui.criar_janela(titulo, [geom], [bg])Inicializa a janela principal nativa (ex: "800x600", "#090A0F").
Janela & Loopgui.iniciar_loop() / gui.fechar_janela()Inicia o event-loop gráfico principal ou encerra a aplicação com segurança.
Containersgui.iniciar_linha([esp], [bg]) / encerrar_linha()Empilha e fecha um container horizontal para posicionar widgets lado a lado.
Containersgui.iniciar_coluna([esp], [bg]) / encerrar_coluna()Empilha e fecha uma coluna vertical aninhada; gui.criar_separador([cor]).
Widgetsgui.criar_rotulo(id, txt, [fg], [bg], [tam])Rótulo dinâmico; atualizado em tempo real via gui.alterar_texto(id, novo_txt).
Widgetsgui.criar_botao(id, txt, callback, [bg], [fg])Botão clicável; aceita função nomeada ou lambda process() { ... }.
Widgetsgui.criar_entrada(id, [larg]) / obter_texto(id)Campo de entrada de texto e leitura/modificação via definir_texto(id, val).
Widgetsgui.criar_slider(id, min, max, [cb])Controle deslizante contínuo; ler valor float com obter_valor_slider(id).
Widgetsgui.criar_caixa_selecao(id, txt, [estado])Checkbox booleano; ler estado com obter_estado_caixa(id) -> bool.
Widgetsgui.criar_lista(id, [w], [h]) / adicionar_item_listaListbox selecionável; ler item ativo com obter_selecao_lista(id).
Canvas 2D/3Dgui.criar_tela(id, larg, alt, [bg]) / limpar_tela(id)Superfície gráfica vetorial acelerada para jogos 2D e projeções 3D.
Canvas 2D/3Dgui.desenhar_linha(id, x1, y1, x2, y2, [cor], [esp])Traça segmento vetorial entre dois pontos 2D projetados.
Canvas 2D/3Dgui.desenhar_retangulo / circulo / poligonoPrimitivas geométricas com preenchimento hexadecimal, borda e espessura.
Canvas 2D/3Dgui.desenhar_texto(id, x, y, txt, [cor], [tam], [alin])Renderiza tipografia no Canvas (alinhamento: "centro", "esquerda", "direita").
Eventos & Timergui.vincular_evento_rato / vincular_evento_tecladoCaptura cliques, arraste (mx, my) e teclas físicas (keysym).
Eventos & Timergui.agendar_atualizacao(ms, callback)Agenda game-loop / animação contínua não-bloqueante em milissegundos.
Diálogosgui.mostrar_mensagem(tit, msg) / confirmar(tit, msg)Exibe modais nativos do sistema operacional.
VOLUME VII

7. Matemática Espacial 3D (math3d) & Computação Quântica (qbit)

Rotações euclidianas, projeção em perspectiva 2D, detecção de colisões e simulação quântica Statevector pura de múltiplos qubits.

7.1 Álgebra Vetorial, Rotações e Projeção em Perspectiva (math3d)

Projetado para operar em conjunto com o operador Pipe (|>), o módulo math3d transforma vértices [x, y, z] em coordenadas de tela (px, py) prontas para serem desenhadas no Canvas:

Função / Operação Retorno Descrição Matemática
math3d.vec3(x, y, z) / add(a,b) / sub(a,b)list [x,y,z]Criação e aritmética vetorial em $\mathbb{R}^3$; scale(v, s).
math3d.dot(a, b) / cross(a, b)float / listProduto escalar ($\vec{a}\cdot\vec{b}$) e produto vetorial ortogonal ($\vec{a}\times\vec{b}$).
math3d.magnitude(v) / normalize(v)float / listNorma euclidiana $\|\vec{v}\|$ e normalização para vetor unitário.
math3d.distance(a, b) / angle_between(a, b)floatDistância 3D entre pontos e ângulo em radianos entre dois vetores.
math3d.rotate_x(v, rad) / rotate_y / rotate_zlist [x,y,z]Aplica matriz de rotação 3D de Euler sobre o ponto/vetor.
math3d.project_2d(v, fov, dist, larg, alt)tuple (px, py)Projeta coordenadas 3D em pixels 2D com perspectiva de câmera.
math3d.sphere_intersect(c1, r1, c2, r2)boolColisão esférica rápida; aabb_intersect(min1, max1, min2, max2).
import "math3d" as math3d

let v1 = math3d.vec3(1.0, 0.0, 0.0)
let v2 = math3d.vec3(0.0, 1.0, 0.0)
let normal = math3d.cross(v1, v2)               // Produto vetorial -> [0.0, 0.0, 1.0]
let angulo = math3d.angle_between(v1, v2)       // 1.570796 rad (90 graus)

// Pipeline de Projeção 3D -> 2D (fov=340, camera_dist=3.8, largura=800, altura=410)
let (tela_x, tela_y) = [0.0, 1.0, 0.0]
    |> math3d.rotate_y(0.65)
    |> math3d.rotate_x(0.35)
    |> math3d.project_2d(340.0, 3.8, 800.0, 410.0)

// Detecção de Colisão 3D (Esferas e AABB Bounding Boxes)
let colidiu = math3d.sphere_intersect([0.0, 0.0, 0.0], 2.0, [1.5, 0.0, 0.0], 1.0) // true

7.2 Simulador Quântico Statevector Puro (qbit)

O módulo qbit opera sobre vetores de estado complexos ($\alpha|0\rangle + \beta|1\rangle$ ou registradores multi-qubit $2^n$). Suporta portas de 1, 2 e 3 qubits, coordenadas da Esfera de Bloch $(x, y, z)$, notação Dirac, entropia de emaranhamento de Von Neumann em ebits, ruído despolarizante e o Algoritmo de Busca de Grover:

Categoria Funções Nativas do Módulo qbit Ação Física / Algorítmica
Portas 1-Qubith_gate(q), x_gate(q), y_gate(q), z_gate(q), s_gate(q), t_gate(q)Superposição de Hadamard, rotações de Pauli ($X,Y,Z$) e portas de fase ($\pi/2, \pi/4$).
Rotações Contínuasrx_gate(q, theta), ry_gate(q, theta), rz_gate(q, phi)Operadores unitários contínuos $R_x(\theta), R_y(\theta), R_z(\phi)$ na Esfera de Bloch.
Multi-Qubit & Bellcnot(reg, c, t), cz(reg, c, t), swap(reg, a, b), toffoli(reg)Portas controladas de emaranhamento e estados de Bell bell_state("phi+").
Tomografia & Mediçãobloch_coords(q), dirac(q), probabilities(q), measure(q)Extrai tupla $(x,y,z)$, string Dirac, dicionário de probabilidades ou colapsa o qubit.
Algoritmos & Ruídogrover_search(alvo_bin), entanglement_entropy(reg), depolarizing_noise(q, p)Oráculo + difusor de Grover, entropia de Von Neumann (ebits) e simulação de decoerência.
import "qbit" as qbit
import "math" as math

// 1. Superposição e Rotação Contínua de Fase em 1 Qubit via Pipe |>
let psi = 0
    |> qbit.h_gate()
    |> qbit.rx_gate(math.pi / 4.0)
    |> qbit.rz_gate(math.pi / 6.0)

print("Notação de Dirac: " + qbit.dirac(psi))
let (bx, by, bz) = qbit.bloch_coords(psi)
let probs = qbit.probabilities(psi)
print(f"Vetor de Bloch: ({bx}, {by}, {bz}) | P(|0>): {round(probs['0'] * 100, 1)}%")

// 2. Emaranhamento Quântico Máximo (Estados de Bell |Φ+⟩ e Entropia de Von Neumann)
let par_bell = qbit.bell_state("phi+")
let entropia = qbit.entanglement_entropy(par_bell)   // 1.0 ebit (emaranhamento máximo)

// 3. Algoritmo Quântico de Busca de Grover em 3 Qubits (Amplificação de Amplitude)
let estado_grover = qbit.grover_search("101")
let dist_grover = qbit.probabilities(estado_grover)
print(f"Probabilidade do alvo |101> após Grover: {round(dist_grover['101'] * 100.0, 2)}%") // ~94.53%
VOLUME VIII

8. Engenharia de Dados Multimodelo com MarcoDB (marcodb)

Motor de banco de dados embarcado com transações ACID, linguagem MQL, viagem no tempo MVCC, Busca Vetorial HNSW para IA, Okapi BM25 e Índice Espacial 3D.

8.1 Operações CRUD, Consultas MQL, Transações ACID e MVCC Time-Travel

import "marcodb" as db

db.connect() // Inicializa o motor MarcoDB em memória ou arquivo persistente

// 1. Transação ACID com Undo Log automático em caso de rollback
db.begin()
db.put("experimentos", "exp_01", {"autor": "Marco", "fidelidade": 0.992, "qubits": 8})
db.put("experimentos", "exp_02", {"autor": "QOrigin", "fidelidade": 0.945, "qubits": 16})
db.commit()

// 2. Consulta declarativa com MQL (MarcoDB Query Language)
let melhores = db.query("SELECT autor, fidelidade, qubits FROM experimentos WHERE fidelidade >= 0.95 ORDER BY fidelidade DESC LIMIT 5")
print(f"Resultado MQL: {melhores}")

// 3. Snapshot MVCC (Viagem no Tempo)
let snap_id = db.snapshot()
db.delete("experimentos", "exp_01")
let estado_passado = db.time_travel("experimentos", snap_id) // Recupera os dados antes do delete!
print(f"Estado recuperado via MVCC (Snapshot #{snap_id}): {estado_passado}")

8.2 Busca Vetorial HNSW (IA), Busca Textual BM25 e Índice Espacial 3D

Subsistema MarcoDB Assinaturas Principais Finalidade Arquitetural
Core CRUD & ACIDconnect([arq]), put(col,id,doc), get(col,id), delete(col,id), begin(), commit(), rollback()Persistência transacional com isolamento e recuperação automática.
MQL & Time-Travelquery(mql_str), snapshot() -> int, time_travel(snap_id, col)Consultas SQL-like sobre documentos JSON e auditoria histórica MVCC.
IA Vetorial HNSWvector_insert(idx, id, vec, meta), vector_search(idx, query_vec, k)Busca de similaridade de cosseno para embeddings de IA e estados quânticos.
Full-Text BM25bm25_index(col, id, texto), bm25_search(col, termo, k)Ranking probabilístico de relevância textual Okapi BM25.
Espacial 3D & Criptospatial_insert(idx, id, [x,y,z], m), spatial_nearest(idx, p, k), blake2b(s), verify_integrity()Busca K-NN euclidiana em 3D, hash criptográfico BLAKE2b e checksum CRC32.
import "marcodb" as db

db.connect()

// 1. Índice Vetorial HNSW (Similaridade de Cosseno para Embeddings de IA e Estados Quânticos)
db.vector_insert("ia_perfis", "Superposicao_Equilibrada", [0.5, 0.5, 0.0], {"tipo": "Coerente"})
db.vector_insert("ia_perfis", "Estado_Fundamental_Zero", [1.0, 0.0, 1.0], {"tipo": "Classico"})

let mais_similar = db.vector_search("ia_perfis", [0.48, 0.52, 0.02], 1)
print(f"Match HNSW: {mais_similar[0]['id']} (Score: {round(mais_similar[0]['score'], 4)})")

// 2. Índice Espacial 3D (Busca por Vizinhos Mais Próximos K-NN ou Raio Esférico)
db.spatial_insert("bloch_3d", "Polo_Norte_|0>", [0.0, 0.0, 1.0], {"eixo": "+Z"})
db.spatial_insert("bloch_3d", "Polo_Leste_|+>", [1.0, 0.0, 0.0], {"eixo": "+X"})

let vizinho_3d = db.spatial_nearest("bloch_3d", [0.85, 0.1, 0.5], 1)
print(f"Polo 3D mais próximo: {vizinho_3d[0]['id']} (Distância: {round(vizinho_3d[0]['distance'], 4)})")

// 3. Auditoria de Integridade CRC32, Hash Criptográfico BLAKE2b e Estatísticas L1 Cache
let hash_chave = db.blake2b("QOrigin-Secret-Key")
let relatorio_db = db.stats()
print(f"Docs: {relatorio_db['documents']} | MVCC v{relatorio_db['mvcc_version']} | Integridade: {db.verify_integrity()}")
VOLUME IX // SHOWCASE OFICIAL 4 Protocolos Completos (.lf)

9. Projetos Reais & Jogos 3D (GUI + Math3D + QBit + MarcoDB)

Quatro aplicações completas prontas para execução no Lucida-Flow Studio (F5) ou compilação para executável nativo (.exe / .app), integrando interface gráfica, projeção 3D em tempo real, computação quântica Statevector e persistência multimodelo MarcoDB.

PROJETO 9.1 // GUI + MATH + MARCODB

🖩 Calculadora Padrão Windows 11 (Dark Mode) com Histórico MQL

Implementação completa da Calculadora Padrão em estilo Fluent Dark do Windows 11. Demonstra o uso de containers horizontais (gui.iniciar_linha), callbacks com Lambdas inline (process() { ... }), fatiamento de strings (visor[:-1] para Backspace), tratamento de divisão por zero, registradores de memória (MC, MR, M+, M-, MS) e persistência automática de cada operação no MarcoDB com consulta via SELECT ... ORDER BY ordem DESC.

// ============================================================================
//  CALCULADORA PADRÃO WINDOWS 11 (DARK MODE) - LUCIDA-FLOW v2 + MARCODB
// ============================================================================

import "gui" as gui
import "math" as math
import "marcodb" as db

// --- 1. ESTADO INTERNO DA CALCULADORA ---
let visor: string = "0"
let expressao_topo: string = ""
let acumulador: float = 0.0
let operador_pendente: string = ""
let aguardando_novo_numero: bool = true
let memoria: float = 0.0
let tem_memoria: bool = false
let total_calculos: int = 0
let ultimo_registro_db: string = "Histórico vazio"

db.connect()


// --- 2. FORMATAÇÃO E ATUALIZAÇÃO DO VISOR FLUENT UI ---

define process formatar_num(n: float) -> string {
    when n == to_int(n) {
        return to_string(to_int(n))
    }
    return to_string(round(n, 8))
}

define process obter_valor_visor() -> float {
    let limpo = visor.replace(",", ".")
    return to_float(limpo)
}

define process atualizar_tela() {
    gui.limpar_tela("visor_canvas")

    // Fundo do cabeçalho e card do visor estilo Windows 11
    gui.desenhar_retangulo("visor_canvas", 4.0, 4.0, 336.0, 142.0, "#1A1A1A", "#2D2D2D", 1)

    // Cabeçalho: Menu + Título "Padrão" + Indicador de Histórico MarcoDB
    gui.desenhar_texto("visor_canvas", 16.0, 22.0, "☰  Padrão", "#FFFFFF", 11, "esquerda")
    gui.desenhar_texto("visor_canvas", 326.0, 22.0, f"🕒 [H] ({total_calculos})", "#A0A0A0", 9, "direita")

    // Linha superior de expressão acumulada (ex: "125 × 4 =")
    gui.desenhar_texto("visor_canvas", 324.0, 54.0, expressao_topo, "#A0A0A0", 10, "direita")

    // Número principal do visor (ajusta o tamanho da fonte automaticamente se for muito longo)
    let tam_fonte = len(visor) > 12 ? 18 : (len(visor) > 9 ? 22 : 28)
    let visor_exibicao = visor.replace(".", ",")
    gui.desenhar_texto("visor_canvas", 324.0, 92.0, visor_exibicao, "#FFFFFF", tam_fonte, "direita")

    // Barra inferior de status dentro do visor (Memória + Última conta no MarcoDB)
    let txt_mem = tem_memoria ? f"M: {formatar_num(memoria)}" : "M: vazia"
    let cor_mem = tem_memoria ? "#60CDFF" : "#555555"
    gui.desenhar_texto("visor_canvas", 16.0, 128.0, txt_mem, cor_mem, 8, "esquerda")
    gui.desenhar_texto("visor_canvas", 324.0, 128.0, ultimo_registro_db, "#6E6E6E", 8, "direita")
}


// --- 3. LÓGICA DE DIGITAÇÃO E OPERAÇÕES MATEMÁTICAS ---

define process digitar_numero(digito: string) {
    when visor == "Erro" {
        visor = "0"
        expressao_topo = ""
    }

    when aguardando_novo_numero {
        visor = digito
        aguardando_novo_numero = false
    } otherwise {
        when visor == "0" {
            visor = digito
        } otherwise {
            when len(visor) < 15 {
                visor += digito
            }
        }
    }
    atualizar_tela()
}

define process digitar_decimal() {
    when aguardando_novo_numero {
        visor = "0."
        aguardando_novo_numero = false
    } otherwise {
        when "." not in visor {
            visor += "."
        }
    }
    atualizar_tela()
}

define process limpar_tudo() {
    visor = "0"
    expressao_topo = ""
    acumulador = 0.0
    operador_pendente = ""
    aguardando_novo_numero = true
    atualizar_tela()
}

define process limpar_entrada() {
    visor = "0"
    aguardando_novo_numero = true
    atualizar_tela()
}

define process apagar_ultimo() {
    when not aguardando_novo_numero and visor != "Erro" {
        when len(visor) > 1 {
            visor = visor[:-1]
            when visor == "-" or visor == "-0" {
                visor = "0"
            }
        } otherwise {
            visor = "0"
        }
        atualizar_tela()
    }
}

define process inverter_sinal() {
    when visor != "0" and visor != "Erro" {
        let atual = obter_valor_visor()
        visor = formatar_num(-atual)
        atualizar_tela()
    }
}

define process aplicar_unario(tipo: string) {
    when visor == "Erro" {
        return
    }
    let x = obter_valor_visor()
    let x_str = formatar_num(x)

    match tipo {
        case "inv" => {
            when x == 0.0 {
                visor = "Erro"
                expressao_topo = f"1/({x_str})"
                aguardando_novo_numero = true
            } otherwise {
                let res = 1.0 / x
                expressao_topo = f"1/({x_str})"
                visor = formatar_num(res)
                aguardando_novo_numero = true
            }
        }
        case "sqr" => {
            let res = x * x
            expressao_topo = f"sqr({x_str})"
            visor = formatar_num(res)
            aguardando_novo_numero = true
        }
        case "sqrt" => {
            when x < 0.0 {
                visor = "Erro"
                expressao_topo = f"√({x_str})"
                aguardando_novo_numero = true
            } otherwise {
                let res = math.sqrt(x)
                expressao_topo = f"√({x_str})"
                visor = formatar_num(res)
                aguardando_novo_numero = true
            }
        }
        case "pct" => {
            let res = (operador_pendente in ["+", "-"]) ? (acumulador * (x / 100.0)) : (x / 100.0)
            visor = formatar_num(res)
            aguardando_novo_numero = true
        }
        else => {}
    }
    atualizar_tela()
}

define process executar_calculo_pendente(segundo_num: float) -> bool {
    match operador_pendente {
        case "+" => { acumulador += segundo_num }
        case "-" => { acumulador -= segundo_num }
        case "×" => { acumulador *= segundo_num }
        case "÷" => {
            when segundo_num == 0.0 {
                visor = "Erro"
                operador_pendente = ""
                aguardando_novo_numero = true
                return false
            }
            acumulador /= segundo_num
        }
        else => { acumulador = segundo_num }
    }
    return true
}

define process escolher_operador(op: string) {
    when visor == "Erro" {
        limpar_tudo()
    }
    let atual = obter_valor_visor()

    when operador_pendente != "" and not aguardando_novo_numero {
        let ok = executar_calculo_pendente(atual)
        when not ok {
            atualizar_tela()
            return
        }
        visor = formatar_num(acumulador)
    } otherwise {
        acumulador = atual
    }

    operador_pendente = op
    expressao_topo = f"{formatar_num(acumulador)} {op}"
    aguardando_novo_numero = true
    atualizar_tela()
}

define process calcular_igual() {
    when operador_pendente == "" or visor == "Erro" {
        return
    }
    let segundo = obter_valor_visor()
    let primeiro_str = formatar_num(acumulador)
    let segundo_str = formatar_num(segundo)
    let op_usado = operador_pendente

    let ok = executar_calculo_pendente(segundo)
    when not ok {
        atualizar_tela()
        return
    }

    let resultado_str = formatar_num(acumulador)
    expressao_topo = f"{primeiro_str} {op_usado} {segundo_str} ="
    visor = resultado_str
    operador_pendente = ""
    aguardando_novo_numero = true

    // Salva a operação no histórico do MarcoDB
    total_calculos += 1
    let resumo = f"{primeiro_str} {op_usado} {segundo_str} = {resultado_str}"
    ultimo_registro_db = resumo
    db.put("historico_calc", f"calc_{total_calculos}", {
        "ordem": total_calculos,
        "expressao": resumo,
        "resultado": acumulador
    })

    atualizar_tela()
}


// --- 4. FUNÇÕES DE MEMÓRIA (MC, MR, M+, M-, MS) E HISTÓRICO MARCODB ---

define process acao_memoria(cmd: string) {
    when visor == "Erro" {
        return
    }
    let val = obter_valor_visor()
    match cmd {
        case "MC" => {
            memoria = 0.0
            tem_memoria = false
        }
        case "MR" => {
            when tem_memoria {
                visor = formatar_num(memoria)
                aguardando_novo_numero = true
            }
        }
        case "M+" => {
            memoria += val
            tem_memoria = true
            aguardando_novo_numero = true
        }
        case "M-" => {
            memoria -= val
            tem_memoria = true
            aguardando_novo_numero = true
        }
        case "MS" => {
            memoria = val
            tem_memoria = true
            aguardando_novo_numero = true
        }
        else => {}
    }
    atualizar_tela()
}

define process mostrar_historico_marcodb() {
    let registros = db.query("SELECT ordem, expressao FROM historico_calc ORDER BY ordem DESC LIMIT 8")
    when len(registros) == 0 {
        gui.exibir_mensagem("Histórico (MarcoDB)", "Nenhum cálculo registrado ainda.")
        return
    }
    let linhas = [f"#{r['ordem']}:  {r['expressao']}" for each r in registros]
    gui.exibir_mensagem("Histórico de Cálculos (MarcoDB MQL)", linhas.join("\n"))
}


// --- 5. ATALHOS DE TECLADO FÍSICO ---

define process ao_teclar(tecla: string) {
    match tecla {
        case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" => digitar_numero(tecla)
        case "comma", "period", "KP_Decimal" => digitar_decimal()
        case "plus", "KP_Add" => escolher_operador("+")
        case "minus", "KP_Subtract" => escolher_operador("-")
        case "asterisk", "KP_Multiply", "x", "X" => escolher_operador("×")
        case "slash", "KP_Divide" => escolher_operador("÷")
        case "Return", "KP_Enter", "equal" => calcular_igual()
        case "BackSpace" => apagar_ultimo()
        case "Escape", "c", "C" => limpar_tudo()
        case "Delete" => limpar_entrada()
        case "h", "H" => mostrar_historico_marcodb()
        else => {}
    }
}


// --- 6. CONSTRUÇÃO DA INTERFACE ESTILO WINDOWS 11 ---

gui.criar_janela("Calculadora", "365x525", "#202020")

// Visor Superior Integrado
gui.criar_tela("visor_canvas", 340, 146, "#202020")

// Barra de Memória (MC, MR, M+, M-, MS + Histórico)
gui.iniciar_linha(3, "#202020")
    gui.criar_botao("b_mc", " MC ", process() { acao_memoria("MC") }, "#202020", "#A0A0A0")
    gui.criar_botao("b_mr", " MR ", process() { acao_memoria("MR") }, "#202020", "#A0A0A0")
    gui.criar_botao("b_mp", " M+ ", process() { acao_memoria("M+") }, "#202020", "#FFFFFF")
    gui.criar_botao("b_mm", " M- ", process() { acao_memoria("M-") }, "#202020", "#FFFFFF")
    gui.criar_botao("b_ms", " MS ", process() { acao_memoria("MS") }, "#202020", "#FFFFFF")
    gui.criar_botao("b_hi", " 🕒 ", "mostrar_historico_marcodb", "#202020", "#60CDFF")
gui.encerrar_linha()

// Linha 1: %, CE, C, Backspace
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_pct", "  %  ", process() { aplicar_unario("pct") }, "#323232", "#FFFFFF")
    gui.criar_botao("b_ce",  " CE  ", "limpar_entrada", "#323232", "#FFFFFF")
    gui.criar_botao("b_c",   "  C  ", "limpar_tudo", "#323232", "#FFFFFF")
    gui.criar_botao("b_del", "  ⌫  ", "apagar_ultimo", "#323232", "#FFFFFF")
gui.encerrar_linha()

// Linha 2: 1/x, x², √x, ÷
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_inv",  " 1/x ", process() { aplicar_unario("inv") }, "#323232", "#FFFFFF")
    gui.criar_botao("b_sqr",  " x²  ", process() { aplicar_unario("sqr") }, "#323232", "#FFFFFF")
    gui.criar_botao("b_sqrt", " √x  ", process() { aplicar_unario("sqrt") }, "#323232", "#FFFFFF")
    gui.criar_botao("b_div",  "  ÷  ", process() { escolher_operador("÷") }, "#323232", "#FFFFFF")
gui.encerrar_linha()

// Linha 3: 7, 8, 9, ×
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_7",   "  7  ", process() { digitar_numero("7") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_8",   "  8  ", process() { digitar_numero("8") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_9",   "  9  ", process() { digitar_numero("9") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_mul", "  ×  ", process() { escolher_operador("×") }, "#323232", "#FFFFFF")
gui.encerrar_linha()

// Linha 4: 4, 5, 6, −
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_4",   "  4  ", process() { digitar_numero("4") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_5",   "  5  ", process() { digitar_numero("5") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_6",   "  6  ", process() { digitar_numero("6") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_sub", "  −  ", process() { escolher_operador("-") }, "#323232", "#FFFFFF")
gui.encerrar_linha()

// Linha 5: 1, 2, 3, +
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_1",   "  1  ", process() { digitar_numero("1") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_2",   "  2  ", process() { digitar_numero("2") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_3",   "  3  ", process() { digitar_numero("3") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_add", "  +  ", process() { escolher_operador("+") }, "#323232", "#FFFFFF")
gui.encerrar_linha()

// Linha 6: +/−, 0, vírgula, = (Destaque Azul Windows 11)
gui.iniciar_linha(4, "#202020")
    gui.criar_botao("b_neg", " +/− ", "inverter_sinal", "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_0",   "  0  ", process() { digitar_numero("0") }, "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_dec", "  ,  ", "digitar_decimal", "#3B3B3B", "#FFFFFF")
    gui.criar_botao("b_eq",  "  =  ", "calcular_igual", "#60CDFF", "#000000")
gui.encerrar_linha()

gui.vincular_evento_teclado("ao_teclar")
atualizar_tela()
gui.iniciar_loop()
PROJETO 9.2 // GUI + MATH3D + QBIT + MARCODB

⚛️ QOrigin Quantum & 3D Lab — Esfera de Bloch Interativa & Telemetria Live

Laboratório científico integrado combinando projeção 3D em perspectiva (math3d.project_2d via operador Pipe |>), portas quânticas de 1 qubit (H, X, Y, Z, S, T, RX, RZ), Estados de Bell, Algoritmo de Busca de Grover em 3 qubits e telemetria contínua no MarcoDB usando simultaneamente Busca Espacial 3D K-NN (spatial_nearest), Busca Vetorial de IA HNSW (vector_search) e consultas MQL.

// ============================================================================
//  QORIGIN QUANTUM & 3D LAB - TESTE INTEGRADO (GUI + MATH3D + QBIT + MARCODB)
// ============================================================================

import "gui" as gui
import "math" as math
import "math3d" as math3d
import "qbit" as qbit
import "marcodb" as db

// --- 1. ESTADO GLOBAL DO LABORATÓRIO E CÂMERA 3D ---
let estado_atual: any = 0
let ang_x: float = 0.35
let ang_y: float = 0.65
let auto_rotacao: bool = true
let passo_historico: int = 0
let ultima_porta: string = "Estado Inicial |0>"
let ultimo_grover: string = "Pressione [G] ou clique no botão Grover"
let estado_proximo_db: string = "|0> (Polo +Z)"
let dist_espacial_db: float = 0.0
let similaridade_ia: float = 1.0

let N_SEG: int = 16
let angulos_anel = [i * (2.0 * math.pi / N_SEG) for each i in range(N_SEG + 1)]

// --- 2. INICIALIZAÇÃO DO MARCODB (ESPACIAL 3D, HNSW VETORIAL E MQL) ---
db.connect()

db.spatial_insert("bloch_3d", "|0> (Polo +Z)", [0.0, 0.0, 1.0], {"fase": "0"})
db.spatial_insert("bloch_3d", "|1> (Polo -Z)", [0.0, 0.0, -1.0], {"fase": "pi"})
db.spatial_insert("bloch_3d", "|+> (Superpos. +X)", [1.0, 0.0, 0.0], {"fase": "0"})
db.spatial_insert("bloch_3d", "|-> (Superpos. -X)", [-1.0, 0.0, 0.0], {"fase": "pi"})
db.spatial_insert("bloch_3d", "|+i> (Fase +Y)", [0.0, 1.0, 0.0], {"fase": "pi/2"})
db.spatial_insert("bloch_3d", "|-i> (Fase -Y)", [0.0, -1.0, 0.0], {"fase": "3pi/2"})

db.vector_insert("perfis_ia", "Base Clássica |0>", [1.0, 0.0, 1.0], {"classe": "Determinístico 0"})
db.vector_insert("perfis_ia", "Base Clássica |1>", [0.0, 1.0, -1.0], {"classe": "Determinístico 1"})
db.vector_insert("perfis_ia", "Superposição Equilibrada", [0.5, 0.5, 0.0], {"classe": "Coerência Máxima"})


// --- 3. FUNÇÕES AUXILIARES DE PROJEÇÃO 3D E TELEMETRIA DO BANCO ---

define process projetar_ponto(ponto_3d: list) -> list =>
    ponto_3d
    |> math3d.rotate_y(ang_y)
    |> math3d.rotate_x(ang_x)
    |> math3d.project_2d(340.0, 3.8, 480.0, 410.0)

define process registrar_telemetria_marcodb(nome_op: string) {
    passo_historico += 1
    ultima_porta = nome_op

    let (bx, by, bz) = qbit.bloch_coords(estado_atual)
    let probs = qbit.probabilities(estado_atual)
    let p0 = "0" in probs ? probs["0"] : 0.0
    let p1 = "1" in probs ? probs["1"] : 0.0

    db.put("telemetria", f"ev_{passo_historico}", {
        "passo": passo_historico,
        "operacao": nome_op,
        "dirac": qbit.dirac(estado_atual),
        "p0": p0,
        "p1": p1,
        "bloch": [bx, by, bz]
    })

    let vizinhos = db.spatial_nearest("bloch_3d", [bx, by, bz], 1)
    when len(vizinhos) > 0 {
        estado_proximo_db = vizinhos[0]["id"]
        dist_espacial_db = vizinhos[0]["distance"]
    }

    let busca_vec = db.vector_search("perfis_ia", [p0, p1, bz], 1)
    when len(busca_vec) > 0 {
        similaridade_ia = busca_vec[0]["score"]
    }
}


// --- 4. RENDERIZADOR 3D + HUD DE TELEMETRIA NO CANVAS ---

define process desenhar_anel_bloch(plano: string, cor: string) {
    let ant_x: float = 0.0
    let ant_y: float = 0.0
    let primeiro: bool = true

    for each t in angulos_anel {
        let c = math.cos(t)
        let s = math.sin(t)

        let pt3d = match plano {
            case "equador" => [c, 0.0, s]
            case "meridiano_x" => [c, s, 0.0]
            else => [0.0, s, c]
        }

        let (px, py) = projetar_ponto(pt3d)
        when not primeiro {
            gui.desenhar_linha("tela", ant_x, ant_y, px, py, cor, 1)
        }
        ant_x = px
        ant_y = py
        primeiro = false
    }
}

define process renderizar_laboratorio() {
    gui.limpar_tela("tela")

    // 1. Anéis da Esfera de Bloch 3D
    desenhar_anel_bloch("equador", "#1E293B")
    desenhar_anel_bloch("meridiano_x", "#152238")
    desenhar_anel_bloch("meridiano_z", "#152238")

    // 2. Eixos 3D
    let (ox, oy) = projetar_ponto([0.0, 0.0, 0.0])
    let (zx1, zy1) = projetar_ponto([0.0, 1.22, 0.0])
    let (zx2, zy2) = projetar_ponto([0.0, -1.22, 0.0])
    let (xx1, xy1) = projetar_ponto([1.22, 0.0, 0.0])
    let (xx2, xy2) = projetar_ponto([-1.22, 0.0, 0.0])
    let (yx1, yy1) = projetar_ponto([0.0, 0.0, 1.22])
    let (yx2, yy2) = projetar_ponto([0.0, 0.0, -1.22])

    gui.desenhar_linha("tela", zx2, zy2, zx1, zy1, "#334155", 1)
    gui.desenhar_linha("tela", xx2, xy2, xx1, xy1, "#334155", 1)
    gui.desenhar_linha("tela", yx2, yy2, yx1, yy1, "#334155", 1)

    gui.desenhar_texto("tela", zx1, zy1 - 12.0, "|0> (+Z)", "#00FFFF", 10)
    gui.desenhar_texto("tela", zx2, zy2 + 12.0, "|1> (-Z)", "#94A3B8", 10)
    gui.desenhar_texto("tela", xx1 + 18.0, xy1, "|+> (+X)", "#39FF14", 10)
    gui.desenhar_texto("tela", yx1 + 18.0, yy1, "|+i> (+Y)", "#B026FF", 10)

    // 3. Vetor de Estado Quântico |psi>
    let (bx, by, bz) = qbit.bloch_coords(estado_atual)
    let (vx, vy) = projetar_ponto([bx, bz, by])
    let (proj_x, proj_y) = projetar_ponto([bx, 0.0, by])

    gui.desenhar_linha("tela", ox, oy, proj_x, proj_y, "#475569", 1)
    gui.desenhar_linha("tela", proj_x, proj_y, vx, vy, "#475569", 1)
    gui.desenhar_linha("tela", ox, oy, vx, vy, "#FF007F", 4)
    gui.desenhar_circulo("tela", ox, oy, 4.0, "#00FFFF", "#00FFFF", 1)
    gui.desenhar_circulo("tela", vx, vy, 7.0, "#FF007F", "#FFFFFF", 2)

    // 4. Painel Lateral Direito no Canvas (HUD Quântico + Telemetria MarcoDB)
    gui.desenhar_retangulo("tela", 475.0, 12.0, 788.0, 398.0, "#090D16", "#1E293B", 2)
    gui.desenhar_texto("tela", 631.0, 32.0, "TELEMETRIA QUÂNTICA", "#00FFFF", 11)

    let probs = qbit.probabilities(estado_atual)
    let p0 = "0" in probs ? probs["0"] : 0.0
    let p1 = "1" in probs ? probs["1"] : 0.0

    gui.desenhar_texto("tela", 631.0, 60.0, f"Ket: {qbit.dirac(estado_atual)}", "#FFFFFF", 8)
    gui.desenhar_texto("tela", 631.0, 82.0, f"Bloch: ({round(bx, 2)}, {round(by, 2)}, {round(bz, 2)})", "#39FF14", 10)

    // Barras de Probabilidade P(|0>) e P(|1>)
    gui.desenhar_texto("tela", 495.0, 110.0, f"P(|0>): {round(p0 * 100.0, 1)}%", "#00FFFF", 9, "esquerda")
    gui.desenhar_retangulo("tela", 495.0, 122.0, 765.0, 134.0, "#1E293B", "#334155", 1)
    gui.desenhar_retangulo("tela", 495.0, 122.0, 495.0 + (270.0 * p0), 134.0, "#00FFFF", "#00FFFF", 1)

    gui.desenhar_texto("tela", 495.0, 152.0, f"P(|1>): {round(p1 * 100.0, 1)}%", "#FF007F", 9, "esquerda")
    gui.desenhar_retangulo("tela", 495.0, 164.0, 765.0, 176.0, "#1E293B", "#334155", 1)
    gui.desenhar_retangulo("tela", 495.0, 164.0, 495.0 + (270.0 * p1), 176.0, "#FF007F", "#FF007F", 1)

    // Seção MarcoDB no HUD
    gui.desenhar_linha("tela", 495.0, 196.0, 765.0, 196.0, "#1E293B", 1)
    gui.desenhar_texto("tela", 631.0, 214.0, "MOTOR MARCODB (LIVE)", "#FF007F", 11)

    let stats = db.stats()
    gui.desenhar_texto("tela", 631.0, 240.0, f"Última Op: {ultima_porta}", "#E2E8F0", 9)
    gui.desenhar_texto("tela", 631.0, 262.0, f"Polo 3D: {estado_proximo_db}", "#F5D300", 9)
    gui.desenhar_texto("tela", 631.0, 282.0, f"Dist. Espacial 3D: {round(dist_espacial_db, 4)}", "#E2E8F0", 9)
    gui.desenhar_texto("tela", 631.0, 302.0, f"Score HNSW (IA): {round(similaridade_ia, 4)}", "#39FF14", 9)
    gui.desenhar_texto("tela", 631.0, 322.0, f"Docs: {stats['documents']} | MVCC v{stats['mvcc_version']}", "#00FFFF", 9)
    gui.desenhar_texto("tela", 631.0, 342.0, f"Cache L1 Hits: {stats['l1_cache_hits']} | CRC32: OK", "#94A3B8", 9)
    gui.desenhar_texto("tela", 631.0, 376.0, ultimo_grover, "#B026FF", 9)

    // Rodapé alinhado à esquerda usando o novo parâmetro de alinhamento!
    gui.desenhar_texto("tela", 16.0, 392.0, "Teclas: [H] [X] [Y] [Z] [S] [T] [R] | [M] Medir | [G] Grover | [Espaço] Pausa", "#94A3B8", 8, "esquerda")
}


// --- 5. CALLBACKS DE PORTAS QUÂNTICAS, ALGORITMOS E INTERAÇÃO ---

define process acao_hadamard() {
    estado_atual = estado_atual |> qbit.h_gate()
    registrar_telemetria_marcodb("Porta Hadamard (H)")
    renderizar_laboratorio()
}

define process acao_pauli_x() {
    estado_atual = estado_atual |> qbit.x_gate()
    registrar_telemetria_marcodb("Porta Pauli-X (NOT)")
    renderizar_laboratorio()
}

define process acao_rotacao_rx() {
    estado_atual = estado_atual |> qbit.rx_gate(math.pi / 4.0) |> qbit.rz_gate(math.pi / 6.0)
    registrar_telemetria_marcodb("Rotação RX(pi/4)+RZ(pi/6)")
    renderizar_laboratorio()
}

define process acao_medir_e_consultar_mql() {
    let colapso = qbit.measure(estado_atual)
    estado_atual = colapso
    registrar_telemetria_marcodb(f"Medição de Born -> |{colapso}>")

    let historico_mql = db.query("SELECT passo, operacao, dirac FROM telemetria ORDER BY passo DESC LIMIT 1")
    when len(historico_mql) > 0 {
        let reg = historico_mql[0]
        gui.alterar_texto("lbl_status", f"MQL Query [Passo #{reg['passo']}]: {reg['operacao']} => Estado colapsado em {reg['dirac']}")
    }
    renderizar_laboratorio()
}

define process acao_grover_e_bell() {
    let bell = qbit.bell_state("phi+")
    let entropia = qbit.entanglement_entropy(bell)
    let reg_grover = qbit.grover_search("101")
    let probs_g = qbit.probabilities(reg_grover)
    let p_alvo = round(probs_g["101"] * 100.0, 1)

    ultimo_grover = f"Grover |101>: {p_alvo}% | Bell: {entropia} ebit"
    gui.alterar_texto("lbl_status", f"Simulação Multi-Qubit concluída! Grover amplificou |101> para {p_alvo}% (Entropia Bell = {entropia} ebit)")
    renderizar_laboratorio()
}

define process ao_pressionar_tecla(tecla: string) {
    let t = tecla.to_lower()
    match t {
        case "h" => acao_hadamard()
        case "x" => acao_pauli_x()
        case "y" => {
            estado_atual = estado_atual |> qbit.y_gate()
            registrar_telemetria_marcodb("Porta Pauli-Y")
        }
        case "z" => {
            estado_atual = estado_atual |> qbit.z_gate()
            registrar_telemetria_marcodb("Porta Pauli-Z (Fase)")
        }
        case "s" => {
            estado_atual = estado_atual |> qbit.s_gate()
            registrar_telemetria_marcodb("Porta de Fase S (pi/2)")
        }
        case "t" => {
            estado_atual = estado_atual |> qbit.t_gate()
            registrar_telemetria_marcodb("Porta T (pi/4)")
        }
        case "r" => acao_rotacao_rx()
        case "m" => acao_medir_e_consultar_mql()
        case "g" => acao_grover_e_bell()
        case "space" => {
            auto_rotacao = not auto_rotacao
        }
        else => {}
    }
    renderizar_laboratorio()
}

define process ao_arrastar_mouse(mx: int, my: int) {
    when mx < 470 {
        ang_y = (mx - 230.0) * 0.012
        ang_x = (my - 205.0) * 0.012
        renderizar_laboratorio()
    }
}

define process loop_animacao() {
    when auto_rotacao {
        ang_y += 0.035
        renderizar_laboratorio()
    }
    gui.agendar_atualizacao(35, "loop_animacao")
}


// --- 6. CONSTRUÇÃO DA INTERFACE COM LAYOUT HORIZONTAL NATIVO ---

gui.criar_janela("QOrigin Quantum & 3D Lab // Lucida-Flow v2 + MarcoDB", "840x610", "#090A0F")

gui.criar_rotulo("lbl_titulo", "LABORATÓRIO QUÂNTICO 3D // ESFERA DE BLOCH & MARCODB", "#00FFFF", "#090A0F")
gui.criar_tela("tela", 800, 410, "#050508")
gui.criar_rotulo("lbl_status", "Arraste a Esfera 3D com o mouse ou use os botões lado a lado abaixo.", "#39FF14", "#090A0F", 10)

// Fileira 1 de Botões (Lado a Lado)
gui.iniciar_linha(10)
    gui.criar_botao("btn_h", "⚡ Porta Hadamard (H)", "acao_hadamard", "#FF007F", "#FFFFFF")
    gui.criar_botao("btn_x", "🔄 Porta Pauli-X (NOT)", "acao_pauli_x", "#1E293B", "#FF007F")
    gui.criar_botao("btn_rx", "🌀 Rotação RX(π/4) + RZ(π/6)", "acao_rotacao_rx", "#1E293B", "#00FFFF")
gui.encerrar_linha()

// Fileira 2 de Botões (Lado a Lado)
gui.iniciar_linha(10)
    gui.criar_botao("btn_m", "🎯 Medir Qubit & Consultar MQL (MarcoDB)", "acao_medir_e_consultar_mql", "#1E293B", "#39FF14")
    gui.criar_botao("btn_g", "⚛️ Executar Busca de Grover (3 Qubits) + Estado de Bell", "acao_grover_e_bell", "#1E293B", "#F5D300")
gui.encerrar_linha()

gui.vincular_evento_rato("tela", "movimento", "ao_arrastar_mouse")
gui.vincular_evento_teclado("ao_pressionar_tecla")

registrar_telemetria_marcodb("Inicialização |0>")
renderizar_laboratorio()
gui.agendar_atualizacao(35, "loop_animacao")
gui.iniciar_loop()
PROJETO 9.3 // GAME ENGINE 30 FPS + QBIT + MATH3D + MARCODB

🎮 Quantum Defender 3D — Caçador de Ressonância na Esfera de Bloch

Jogo arcade/científico 3D em tempo real (30 FPS via gui.agendar_atualizacao). O jogador controla o vetor de estado quântico $|\psi\rangle$ aplicando portas unitárias (H, X, Y, Z, S, T) e rotações contínuas (RX, RY, RZ) para atingir $\ge 82\%$ de fidelidade ($\langle\psi|\phi_{\text{alvo}}\rangle$) com o Orbe de Ressonância enquanto desvia de Minas de Decoerência orbitais e armazena o ranking em tempo real no MarcoDB (com índices orbes_3d, vetores_ia e MQL).

// ============================================================================
// JOGO: QUANTUM DEFENDER 3D // CAÇADOR DE RESSONÂNCIA (LAYOUT COMPACTO)
// Motor: Lucida-Flow v2.0 + Math3D + QBit Statevector + MarcoDB Live
// ============================================================================

import "gui" as gui
import "math" as math
import "math3d" as math3d
import "qbit" as qbit
import "dado" as dado
import "marcodb" as db

db.connect(":memory:")
db.begin()
db.insert("ranking", {"id": 1, "piloto": "QOrigin-Bot", "pontos": 500, "nivel": 2})
db.insert("ranking", {"id": 2, "piloto": "Bloch-Master", "pontos": 1200, "nivel": 4})
db.commit()

let estado_q = qbit.create_register(1)
let cam_rot_x = 0.38
let cam_rot_y = -0.62
let mouse_last_x = 0
let mouse_last_y = 0
let arrastando = false

let pontos = 0
let recorde = 1200
let combo = 1
let nivel = 1
let capturas_total = 0
let escudo = 100.0
let carga_grover = 100.0
let tempo_pulso = 0
let game_over = false
let msg_combate = "Use [W,A,S,D / Setas] ou Portas [H][X][Y][Z] para alinhar ao Orbe Verde!"
let ultima_porta = "Estado Inicial |0>"

let alvo_theta = 1.0
let alvo_phi = 0.5
let alvo_x = 0.0
let alvo_y = 1.0
let alvo_z = 0.0
let fidelidade_atual = 0.0
let dist_alvo_3d = 1.41

let angulo_minas = 0.0
let mina1_x = 1.0
let mina1_y = 0.0
let mina1_z = 0.0
let mina2_x = -1.0
let mina2_y = 0.0
let mina2_z = 0.0

let aneis_esfera = []
let n_segmentos = 24
for each i in range(0, n_segmentos) {
    let a1 = (to_float(i) / to_float(n_segmentos)) * 2.0 * math.pi
    let a2 = (to_float(i + 1) / to_float(n_segmentos)) * 2.0 * math.pi
    aneis_esfera.append([math.cos(a1), 0.0, math.sin(a1), math.cos(a2), 0.0, math.sin(a2)])
    aneis_esfera.append([math.cos(a1), math.sin(a1), 0.0, math.cos(a2), math.sin(a2), 0.0])
    aneis_esfera.append([0.0, math.cos(a1), math.sin(a1), 0.0, math.cos(a2), math.sin(a2)])
}

define process gerar_novo_alvo() {
    alvo_theta = (dado.flutuante() * 0.75 + 0.12) * math.pi
    alvo_phi = dado.flutuante() * 2.0 * math.pi

    alvo_x = math.sin(alvo_theta) * math.cos(alvo_phi)
    alvo_y = math.sin(alvo_theta) * math.sin(alvo_phi)
    alvo_z = math.cos(alvo_theta)

    let id_orbe = f"orbe_{capturas_total + 1}"
    db.spatial_insert("orbes_3d", id_orbe, [alvo_x, alvo_y, alvo_z], {"nivel": nivel})
    db.vector_insert("vetores_ia", id_orbe, [alvo_x, alvo_y, alvo_z], {"pontos": combo * 100})
}

define process calcular_fidelidade() {
    let coords = qbit.bloch_coords(estado_q)
    let bx = coords[0]
    let by = coords[1]
    let bz = coords[2]

    dist_alvo_3d = math3d.dist3d([bx, by, bz], [alvo_x, alvo_y, alvo_z])

    let prod_escalar = (bx * alvo_x) + (by * alvo_y) + (bz * alvo_z)
    fidelidade_atual = math.clamp((1.0 + prod_escalar) * 50.0, 0.0, 100.0)
}

define process colapsar_alvo() {
    when not game_over {
        calcular_fidelidade()
        when fidelidade_atual >= 82.0 {
            let ganho = (100 + to_int(fidelidade_atual)) * combo
            pontos += ganho
            capturas_total += 1
            combo = to_int(math.clamp(to_float(combo + 1), 1.0, 10.0))
            escudo = math.clamp(escudo + 14.0, 0.0, 100.0)
            carga_grover = math.clamp(carga_grover + 25.0, 0.0, 100.0)
            tempo_pulso = 8

            when capturas_total % 4 == 0 {
                nivel += 1
            }

            when pontos > recorde {
                recorde = pontos
            }

            db.begin()
            db.insert("ranking", {
                "id": capturas_total + 10,
                "piloto": "Voce (Live)",
                "pontos": pontos,
                "nivel": nivel,
                "fidelidade": round(fidelidade_atual, 1)
            })
            db.commit()

            msg_combate = f"⚡ RESSONÂNCIA CAPTURADA! +{ganho} pts (Combo x{combo})"
            gerar_novo_alvo()
            calcular_fidelidade()
        } otherwise {
            combo = 1
            escudo = math.clamp(escudo - 8.0, 0.0, 100.0)
            msg_combate = f"⚠️ Fidelidade insuficiente ({round(fidelidade_atual, 1)}%). Aproxime-se a 82%+!"
        }
    }
}

define process atualizar_metricas() {
    calcular_fidelidade()
    when fidelidade_atual >= 92.0 and not game_over {
        colapsar_alvo()
    }
}

define process reiniciar_jogo() {
    estado_q = qbit.create_register(1)
    pontos = 0
    combo = 1
    nivel = 1
    capturas_total = 0
    escudo = 100.0
    carga_grover = 100.0
    game_over = false
    ultima_porta = "Reinicialização |0>"
    msg_combate = "🚀 Missão Reiniciada! Alinhe o vetor rosa ao Orbe Verde!"
    gerar_novo_alvo()
    calcular_fidelidade()
}

define process aplicar_porta(nome_porta: string) {
    when not game_over {
        match nome_porta {
            case "H" => {
                estado_q = qbit.h_gate(estado_q)
                ultima_porta = "Porta Hadamard (H)"
            }
            case "X" => {
                estado_q = qbit.x_gate(estado_q)
                ultima_porta = "Porta Pauli-X (Inversão)"
            }
            case "Y" => {
                estado_q = qbit.y_gate(estado_q)
                ultima_porta = "Porta Pauli-Y"
            }
            case "Z" => {
                estado_q = qbit.z_gate(estado_q)
                ultima_porta = "Porta Pauli-Z (Fase)"
            }
            case "S" => {
                estado_q = qbit.s_gate(estado_q)
                ultima_porta = "Porta de Fase S (π/2)"
            }
            case "T" => {
                estado_q = qbit.t_gate(estado_q)
                ultima_porta = "Porta T (π/4)"
            }
            case "RX+" => {
                estado_q = qbit.rx_gate(estado_q, 0.22)
                ultima_porta = "Rotação Contínua RX(+)"
            }
            case "RX-" => {
                estado_q = qbit.rx_gate(estado_q, -0.22)
                ultima_porta = "Rotação Contínua RX(-)"
            }
            case "RY+" => {
                estado_q = qbit.ry_gate(estado_q, 0.22)
                ultima_porta = "Rotação Contínua RY(+)"
            }
            case "RY-" => {
                estado_q = qbit.ry_gate(estado_q, -0.22)
                ultima_porta = "Rotação Contínua RY(-)"
            }
            case "RZ+" => {
                estado_q = qbit.rz_gate(estado_q, 0.22)
                ultima_porta = "Rotação Contínua RZ(+)"
            }
            case "RZ-" => {
                estado_q = qbit.rz_gate(estado_q, -0.22)
                ultima_porta = "Rotação Contínua RZ(-)"
            }
        }

        atualizar_metricas()
    }
}

define process disparar_pulso_grover() {
    when game_over {
        reiniciar_jogo()
    } otherwise {
        when carga_grover < 100.0 {
            msg_combate = f"⏳ Carga Grover em {round(carga_grover, 0)}% (Capture orbes para carregar 100%)"
        } otherwise {
            let res_grover = qbit.grover_search("101")
            carga_grover = 0.0
            escudo = math.clamp(escudo + 25.0, 0.0, 100.0)

            estado_q = qbit.create_register(1)
            estado_q = qbit.ry_gate(estado_q, alvo_theta * 0.90)
            estado_q = qbit.rz_gate(estado_q, alvo_phi)

            ultima_porta = f"PULSO DE GROVER |{res_grover}> (3 Qubits)"
            msg_combate = "⚛️ PULSO DE GROVER ATIVADO! Pressione [Espaço] para Colapsar o Orbe!"
            calcular_fidelidade()
        }
    }
}

define process acao_porta_h() { aplicar_porta("H") }
define process acao_porta_x() { aplicar_porta("X") }
define process acao_porta_z() { aplicar_porta("Z") }
define process acao_rot_rx()  { aplicar_porta("RX+") }
define process acao_rot_rz()  { aplicar_porta("RZ+") }

define process renderizar_cena() {
    gui.limpar_tela("tela_3d")

    gui.desenhar_retangulo("tela_3d", 6.0, 6.0, 934.0, 419.0, "", "#1E293B", 1)

    for each seg in aneis_esfera {
        let p1 = [seg[0], seg[1], seg[2]] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        let p2 = [seg[3], seg[4], seg[5]] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        gui.desenhar_linha("tela_3d", p1[0], p1[1], p2[0], p2[1], "#132038", 1)
    }

    let p_z_top = [0.0, 1.18, 0.0] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_z_bot = [0.0, -1.18, 0.0] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_x_pos = [1.18, 0.0, 0.0] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_x_neg = [-1.18, 0.0, 0.0] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_y_pos = [0.0, 0.0, 1.18] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_y_neg = [0.0, 0.0, -1.18] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    gui.desenhar_linha("tela_3d", p_z_top[0], p_z_top[1], p_z_bot[0], p_z_bot[1], "#334155", 1)
    gui.desenhar_linha("tela_3d", p_x_pos[0], p_x_pos[1], p_x_neg[0], p_x_neg[1], "#334155", 1)
    gui.desenhar_linha("tela_3d", p_y_pos[0], p_y_pos[1], p_y_neg[0], p_y_neg[1], "#334155", 1)

    gui.desenhar_texto("tela_3d", p_z_top[0], p_z_top[1] - 10.0, "|0> (+Z)", "#00FFFF", 9, "center")
    gui.desenhar_texto("tela_3d", p_z_bot[0], p_z_bot[1] + 10.0, "|1> (-Z)", "#94A3B8", 9, "center")
    gui.desenhar_texto("tela_3d", p_x_pos[0] + 16.0, p_x_pos[1], "|+> (+X)", "#39FF14", 9, "center")
    gui.desenhar_texto("tela_3d", p_y_pos[0] - 16.0, p_y_pos[1], "|+i> (+Y)", "#C084FC", 9, "center")

    let pm1 = [mina1_x, mina1_y, mina1_z] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pm2 = [mina2_x, mina2_y, mina2_z] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    gui.desenhar_circulo("tela_3d", pm1[0], pm1[1], 6.0, "#FF004D", "#FCA5A5", 2)
    gui.desenhar_texto("tela_3d", pm1[0], pm1[1] - 12.0, "RUÍDO", "#FF004D", 8, "center")
    gui.desenhar_circulo("tela_3d", pm2[0], pm2[1], 6.0, "#FF004D", "#FCA5A5", 2)
    gui.desenhar_texto("tela_3d", pm2[0], pm2[1] - 12.0, "RUÍDO", "#FF004D", 8, "center")

    let p_alvo = [alvo_x, alvo_z, alvo_y] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_centro = [0.0, 0.0, 0.0] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let raio_orbe = 9.0 + (tempo_pulso > 0 ? 4.0 : 0.0)
    let cor_orbe = fidelidade_atual >= 82.0 ? "#FACC15" : "#39FF14"

    gui.desenhar_linha("tela_3d", p_centro[0], p_centro[1], p_alvo[0], p_alvo[1], "#14532D", 1)
    gui.desenhar_circulo("tela_3d", p_alvo[0], p_alvo[1], raio_orbe + 4.0, "", cor_orbe, 1)
    gui.desenhar_circulo("tela_3d", p_alvo[0], p_alvo[1], raio_orbe, cor_orbe, "#FFFFFF", 2)
    gui.desenhar_texto("tela_3d", p_alvo[0], p_alvo[1] - 16.0, "ALVO QUÂNTICO", cor_orbe, 8, "center")

    let coords = qbit.bloch_coords(estado_q)
    let bx = coords[0]
    let by = coords[1]
    let bz = coords[2]
    let p_vec = [bx, bz, by] |> math3d.rotate_y(cam_rot_y) |> math3d.rotate_x(cam_rot_x) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    when fidelidade_atual >= 82.0 {
        gui.desenhar_linha("tela_3d", p_vec[0], p_vec[1], p_alvo[0], p_alvo[1], "#00FFFF", 2)
    }

    gui.desenhar_linha("tela_3d", p_centro[0], p_centro[1], p_vec[0], p_vec[1], "#FF007F", 4)
    gui.desenhar_circulo("tela_3d", p_centro[0], p_centro[1], 4.0, "#00FFFF", "#00FFFF", 1)
    gui.desenhar_circulo("tela_3d", p_vec[0], p_vec[1], 8.0, "#FF007F", "#FFFFFF", 2)

    gui.desenhar_texto("tela_3d", 18.0, 404.0, "Teclas: [W/A/S/D] Girar | [H][X][Y][Z] Portas | [Espaço] Capturar | [G] Grover", "#94A3B8", 9, "left")

    // Painel Direito Compacto
    gui.desenhar_retangulo("tela_3d", 560.0, 14.0, 924.0, 412.0, "#070911", "#1E293B", 1)

    gui.desenhar_texto("tela_3d", 742.0, 32.0, "TELEMETRIA DE COMBATE QUÂNTICO", "#00FFFF", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 52.0, f"PONTOS: {pontos}  |  RECORDE: {recorde}", "#FACC15", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 70.0, f"Nível: {nivel}  |  Combo: x{combo}  |  Orbes: {capturas_total}", "#39FF14", 9, "center")

    let ket_str = qbit.dirac(estado_q)
    gui.desenhar_texto("tela_3d", 742.0, 88.0, f"Estado: {ket_str}", "#E2E8F0", 9, "center")

    gui.desenhar_texto("tela_3d", 576.0, 110.0, f"Fidelidade c/ Alvo: {round(fidelidade_atual, 1)}% (Meta: 82%)", "#00FFFF", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 120.0, 906.0, 133.0, "#1E293B", "#334155", 1)
    let larg_fid = (fidelidade_atual / 100.0) * 330.0
    let cor_barra_fid = fidelidade_atual >= 82.0 ? "#FACC15" : "#00FFFF"
    when larg_fid > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 120.0, 576.0 + larg_fid, 133.0, cor_barra_fid, cor_barra_fid, 1)
    }

    gui.desenhar_texto("tela_3d", 576.0, 147.0, f"Coerência do Qubit (Escudo): {round(escudo, 0)}%", "#FF007F", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 157.0, 906.0, 170.0, "#1E293B", "#334155", 1)
    let larg_esc = (escudo / 100.0) * 330.0
    when larg_esc > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 157.0, 576.0 + larg_esc, 170.0, "#FF007F", "#FF007F", 1)
    }

    gui.desenhar_texto("tela_3d", 576.0, 184.0, f"Carga Algoritmo de Grover [G]: {round(carga_grover, 0)}%", "#C084FC", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 194.0, 906.0, 207.0, "#1E293B", "#334155", 1)
    let larg_grov = (carga_grover / 100.0) * 330.0
    when larg_grov > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 194.0, 576.0 + larg_grov, 207.0, "#C084FC", "#C084FC", 1)
    }

    gui.desenhar_linha("tela_3d", 576.0, 220.0, 906.0, 220.0, "#1E293B", 1)
    gui.desenhar_texto("tela_3d", 742.0, 235.0, "MOTOR MARCODB (TELEMETRIA 3D & MQL)", "#FF007F", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 254.0, f"Última Porta: {ultima_porta}", "#E2E8F0", 9, "center")
    gui.desenhar_texto("tela_3d", 742.0, 272.0, f"Distância Espacial 3D ao Orbe: {round(dist_alvo_3d, 3)}", "#39FF14", 9, "center")

    let st = db.stats()
    let n_docs = "documents" in st ? st["documents"] : (capturas_total + 2)
    let v_mvcc = "mvcc_version" in st ? st["mvcc_version"] : (capturas_total + 2)
    gui.desenhar_texto("tela_3d", 742.0, 290.0, f"Docs MQL: {n_docs} | MVCC v{v_mvcc} | CRC32: OK", "#00FFFF", 9, "center")

    gui.desenhar_texto("tela_3d", 742.0, 312.0, "🏆 TOP RANKING MQL (SELECT ORDER BY):", "#FACC15", 9, "center")
    let top_pilotos = db.query("SELECT * FROM ranking ORDER BY pontos DESC LIMIT 3")
    let y_rank = 330.0
    let pos_rk = 1
    for each reg in top_pilotos {
        let linha_rk = f"{pos_rk}. {reg['piloto']} -> {reg['pontos']} pts (Nv.{reg['nivel']})"
        gui.desenhar_texto("tela_3d", 742.0, y_rank, linha_rk, "#CBD5E1", 9, "center")
        y_rank += 17.0
        pos_rk += 1
    }

    when game_over {
        gui.desenhar_retangulo("tela_3d", 80.0, 155.0, 480.0, 265.0, "#090A0F", "#FF004D", 2)
        gui.desenhar_texto("tela_3d", 280.0, 188.0, "💥 DECOERÊNCIA TOTAL DO QUBIT!", "#FF004D", 13, "center")
        gui.desenhar_texto("tela_3d", 280.0, 216.0, f"Pontuação Final: {pontos} pts | Orbes: {capturas_total}", "#FFFFFF", 10, "center")
        gui.desenhar_texto("tela_3d", 280.0, 240.0, "Pressione [G] ou clique em Pulso de Grover para Reiniciar", "#39FF14", 9, "center")
    }

    gui.desenhar_texto("tela_3d", 742.0, 396.0, "Arraste a Esfera 3D com o rato para girar a câmara", "#C084FC", 8, "center")
}

define process loop_jogo() {
    when not game_over {
        let vel_mina = 0.035 + (to_float(nivel) * 0.006)
        angulo_minas += vel_mina

        mina1_x = math.cos(angulo_minas)
        mina1_y = math.sin(angulo_minas * 0.7) * 0.5
        mina1_z = math.sin(angulo_minas)

        mina2_x = -math.cos(angulo_minas * 0.8)
        mina2_y = -math.sin(angulo_minas * 0.6) * 0.5
        mina2_z = -math.sin(angulo_minas * 0.8)

        let coords = qbit.bloch_coords(estado_q)
        let pos_jogador = [coords[0], coords[2], coords[1]]
        let d_mina1 = math3d.dist3d(pos_jogador, [mina1_x, mina1_y, mina1_z])
        let d_mina2 = math3d.dist3d(pos_jogador, [mina2_x, mina2_y, mina2_z])

        when d_mina1 < 0.30 or d_mina2 < 0.30 {
            escudo = math.clamp(escudo - 2.2, 0.0, 100.0)
            combo = 1
            msg_combate = "⚠️ ALERTA: Colisão 3D com Mina de Ruído! Afaste o vetor!"
        }

        escudo = math.clamp(escudo - (0.06 + to_float(nivel) * 0.01), 0.0, 100.0)

        when escudo <= 0.0 {
            game_over = true
            msg_combate = f"💥 FIM DE JOGO! Pontuação registada no MarcoDB: {pontos} pts."
        }
    }

    when tempo_pulso > 0 {
        tempo_pulso -= 1
    }

    gui.alterar_texto("lbl_status", msg_combate)
    renderizar_cena()
    gui.agendar_atualizacao(35, "loop_jogo")
}

define process ao_clicar_mouse(x: int, y: int) {
    mouse_last_x = x
    mouse_last_y = y
    arrastando = true
}

define process ao_arrastar_mouse(x: int, y: int) {
    when arrastando {
        let dx = to_float(x - mouse_last_x)
        let dy = to_float(y - mouse_last_y)
        cam_rot_y += dx * 0.01
        cam_rot_x = math.clamp(cam_rot_x + (dy * 0.01), -1.4, 1.4)
        mouse_last_x = x
        mouse_last_y = y
    }
}

define process ao_teclar(tecla: string) {
    match tecla {
        case "h", "H" => aplicar_porta("H")
        case "x", "X" => aplicar_porta("X")
        case "y", "Y" => aplicar_porta("Y")
        case "z", "Z" => aplicar_porta("Z")
        case "f", "F" => aplicar_porta("S")
        case "t", "T" => aplicar_porta("T")
        case "w", "W", "Up" => aplicar_porta("RX+")
        case "s", "S", "Down" => aplicar_porta("RX-")
        case "a", "A", "Left" => aplicar_porta("RZ-")
        case "d", "D", "Right" => aplicar_porta("RZ+")
        case "e", "E" => aplicar_porta("RY+")
        case "q", "Q" => aplicar_porta("RY-")
        case "space", "Return", "m", "M" => colapsar_alvo()
        case "g", "G" => disparar_pulso_grover()
        case "r", "R" => reiniciar_jogo()
    }
}

gui.criar_janela("Quantum Defender 3D // Bloch Sphere Game + MarcoDB", "960x610", "#050508")

gui.criar_rotulo("lbl_titulo", "🎮 QUANTUM DEFENDER 3D // CAÇADOR DE RESSONÂNCIA NA ESFERA DE BLOCH", "#00FFFF", "#050508", 11)
gui.criar_tela("tela_3d", 940, 425, "#050508")
gui.criar_rotulo("lbl_status", msg_combate, "#39FF14", "#050508", 10)

gui.iniciar_linha(8, "#050508")
gui.criar_botao("btn_h", "⚡ Porta Hadamard [H]", acao_porta_h, "#161B26", "#FACC15")
gui.criar_botao("btn_x", "🔄 Porta Pauli-X [X]", acao_porta_x, "#161B26", "#FF007F")
gui.criar_botao("btn_z", "💠 Porta Pauli-Z [Z]", acao_porta_z, "#161B26", "#00FFFF")
gui.criar_botao("btn_rx", "🌀 Rotacionar RX [W/S]", acao_rot_rx, "#161B26", "#39FF14")
gui.criar_botao("btn_rz", "🧭 Rotacionar RZ [A/D]", acao_rot_rz, "#161B26", "#C084FC")
gui.encerrar_linha()

gui.iniciar_linha(10, "#050508")
gui.criar_botao("btn_capturar", "🎯 Colapsar & Capturar Orbe [Espaço]", colapsar_alvo, "#161B26", "#39FF14")
gui.criar_botao("btn_grover", "⚛️ Disparar Super-Pulso de Grover [G]", disparar_pulso_grover, "#161B26", "#FACC15")
gui.criar_botao("btn_reset", "🔁 Reiniciar Missão [R]", reiniciar_jogo, "#161B26", "#94A3B8")
gui.encerrar_linha()

gui.vincular_evento_rato("tela_3d", "clique", ao_clicar_mouse)
gui.vincular_evento_rato("tela_3d", "arrastar", ao_arrastar_mouse)
gui.vincular_evento_teclado(ao_teclar)

gerar_novo_alvo()
calcular_fidelidade()
loop_jogo()
gui.iniciar_loop()
PROJETO 9.4 // 3D SPACE COMBAT + QBIT WARP + MARCODB RADAR

🚀 Star Interceptor 3D — Combate Espacial no Hiperespaço & Radar MarcoDB

Simulador de combate espacial 3D em corredor de hiperespaço com layout compacto (960x610). Renderiza octógonos 3D em perspectiva contínua, caças interceptadores hostis, asteroides giratórios, feixes duplos de plasma e mira holográfica via gui.desenhar_poligono e math3d.project_2d. Inclui Singularidade Quântica de Grover (qbit.grover_search("111")), conversão de energia para escudos defletores e radar espacial 3D em tempo real no MarcoDB.

// ============================================================================
// JOGO: STAR INTERCEPTOR 3D // COMBATE ESPACIAL NO HIPERESPAÇO (LAYOUT COMPACTO)
// Motor: Lucida-Flow v2.0 + Math3D + QBit Warp Engine + MarcoDB Live
// ============================================================================

import "gui" as gui
import "math" as math
import "math3d" as math3d
import "qbit" as qbit
import "dado" as dado
import "marcodb" as db

// 1. Inicialização do Banco de Dados MarcoDB (Ranking MQL + Radar Espacial 3D)
db.connect(":memory:")
db.begin()
db.insert("ranking", {"id": 1, "piloto": "Ace-Fox", "pontos": 800, "setor": 2})
db.insert("ranking", {"id": 2, "piloto": "Commander-Q", "pontos": 1800, "setor": 4})
db.commit()

// 2. Estado 3D da Nave do Jogador e Câmera
let nave_x = 0.0
let nave_y = -0.25
let nave_z = -0.85
let nave_inclina = 0.0
let cam_yaw = 0.0
let cam_pitch = 0.12

// 3. Estado do Canhão Duplo de Plasma 3D
let laser_ativo = false
let laser_x = 0.0
let laser_y = 0.0
let laser_z = -0.85
let energia_armas = 100.0
let flash_explosao = 0
let exp_x = 0.0
let exp_y = 0.0
let exp_z = 0.5

// 4. Inimigos 3D (2 Caças Interceptadores + 1 Asteroide Pesado)
let inim1_x = -0.6
let inim1_y = 0.3
let inim1_z = 2.4

let inim2_x = 0.7
let inim2_y = -0.2
let inim2_z = 3.1

let ast_x = 0.0
let ast_y = 0.5
let ast_z = 2.8
let ast_rot = 0.0

// 5. Telemetria de Combate e Pontuação
let pontos = 0
let recorde = 1800
let abates = 0
let combo = 1
let setor = 1
let escudo = 100.0
let carga_warp = 100.0
let dist_radar = 2.5
let game_over = false
let ultima_acao = "Propulsores Online"
let msg_hud = "Use [W/A/S/D] para pilotar a Nave 3D e [Espaço] para disparar Plasma!"

// 6. Anéis do Túnel de Hiperespaço 3D
let fase_tunel = 0.0
let aneis_octogono = []
let n_lados = 12
for each i in range(0, n_lados) {
    let a1 = (to_float(i) / to_float(n_lados)) * 2.0 * math.pi
    let a2 = (to_float(i + 1) / to_float(n_lados)) * 2.0 * math.pi
    aneis_octogono.append([math.cos(a1) * 1.65, math.sin(a1) * 1.25, math.cos(a2) * 1.65, math.sin(a2) * 1.25])
}

// ============================================================================
// PROCESSOS DE MECÂNICA DO JOGO E MARCODB (EM ORDEM ESTRITA DE DECLARAÇÃO)
// ============================================================================

define process spawn_inimigo1() {
    inim1_x = (dado.flutuante() * 2.0 - 1.0) * 1.15
    inim1_y = (dado.flutuante() * 2.0 - 1.0) * 0.75
    inim1_z = 2.4 + dado.flutuante() * 0.6
}

define process spawn_inimigo2() {
    inim2_x = (dado.flutuante() * 2.0 - 1.0) * 1.15
    inim2_y = (dado.flutuante() * 2.0 - 1.0) * 0.75
    inim2_z = 2.7 + dado.flutuante() * 0.7
}

define process spawn_asteroide() {
    ast_x = (dado.flutuante() * 2.0 - 1.0) * 1.05
    ast_y = (dado.flutuante() * 2.0 - 1.0) * 0.70
    ast_z = 2.6 + dado.flutuante() * 0.6
}

define process reiniciar_jogo() {
    nave_x = 0.0
    nave_y = -0.25
    nave_inclina = 0.0
    laser_ativo = false
    pontos = 0
    abates = 0
    combo = 1
    setor = 1
    escudo = 100.0
    energia_armas = 100.0
    carga_warp = 100.0
    game_over = false
    ultima_acao = "Sistemas Reiniciados"
    msg_hud = "🚀 Star Interceptor 3D pronto! Use [W/A/S/D] para voar e [Espaço] para atirar!"
    spawn_inimigo1()
    spawn_inimigo2()
    spawn_asteroide()
}

define process registrar_abate(pts_base: int, tipo_alvo: string, ax: float, ay: float, az: float) {
    let ganho = pts_base * combo
    pontos += ganho
    abates += 1
    combo = to_int(math.clamp(to_float(combo + 1), 1.0, 10.0))
    carga_warp = math.clamp(carga_warp + 20.0, 0.0, 100.0)
    escudo = math.clamp(escudo + 6.0, 0.0, 100.0)

    flash_explosao = 6
    exp_x = ax
    exp_y = ay
    exp_z = az

    when abates % 5 == 0 {
        setor += 1
    }

    when pontos > recorde {
        recorde = pontos
    }

    let id_alvo = f"alvo_{abates}"
    db.spatial_insert("radar_3d", id_alvo, [ax, ay, az], {"tipo": tipo_alvo, "setor": setor})
    db.vector_insert("telemetria_ia", id_alvo, [ax, ay, az], {"pontos": ganho})

    db.begin()
    db.insert("ranking", {
        "id": abates + 10,
        "piloto": "Voce (Star-1)",
        "pontos": pontos,
        "setor": setor
    })
    db.commit()

    ultima_acao = f"Abate: {tipo_alvo} (+{ganho})"
    msg_hud = f"💥 {tipo_alvo} DESTRUÍDO! +{ganho} pts (Combo x{combo})"
}

define process disparar_laser() {
    when not game_over {
        when not laser_ativo and energia_armas >= 12.0 {
            laser_ativo = true
            laser_x = nave_x
            laser_y = nave_y
            laser_z = nave_z + 0.25
            energia_armas = math.clamp(energia_armas - 12.0, 0.0, 100.0)
            ultima_acao = "Canhões Duplos de Plasma"
        }
    }
}

define process ativar_bomba_quantica() {
    when game_over {
        reiniciar_jogo()
    } otherwise {
        when carga_warp < 100.0 {
            msg_hud = f"⏳ Bomba Quântica em {round(carga_warp, 0)}% (Abata naves para carregar 100%)"
        } otherwise {
            let estado_warp = qbit.grover_search("111")
            carga_warp = 0.0
            escudo = math.clamp(escudo + 30.0, 0.0, 100.0)
            energia_armas = 100.0

            registrar_abate(250, "Esquadrão Quântico", inim1_x, inim1_y, inim1_z)
            spawn_inimigo1()
            spawn_inimigo2()
            spawn_asteroide()

            ultima_acao = f"BOMBA QUÂNTICA |{estado_warp}>"
            msg_hud = "⚛️ SINGULARIDADE QUÂNTICA DE GROVER ATIVADA! Setor limpo e escudo restaurado!"
        }
    }
}

define process ativar_turbo_escudo() {
    when not game_over {
        when energia_armas >= 40.0 and escudo < 100.0 {
            energia_armas = math.clamp(energia_armas - 40.0, 0.0, 100.0)
            escudo = math.clamp(escudo + 35.0, 0.0, 100.0)
            ultima_acao = "Conversão Plasma -> Escudo"
            msg_hud = "🛡️ Energia das armas transferida para os Escudos Defletores (+35%)!"
        } otherwise {
            msg_hud = "⚠️ Energia de plasma insuficiente (mín. 40%) ou escudo já está em 100%!"
        }
    }
}

define process mover_nave(dx: float, dy: float) {
    when not game_over {
        nave_x = math.clamp(nave_x + dx, -1.15, 1.15)
        nave_y = math.clamp(nave_y + dy, -0.78, 0.78)
        when dx < 0.0 {
            nave_inclina = -0.35
        }
        when dx > 0.0 {
            nave_inclina = 0.35
        }
        cam_yaw = nave_x * 0.12
    }
}

// Callbacks diretos para os botões da interface gráfica (+Y = Subir, -Y = Mergulhar)
define process acao_esq()   { mover_nave(-0.18, 0.0) }
define process acao_dir()   { mover_nave(0.18, 0.0) }
define process acao_cima()  { mover_nave(0.0, 0.16) }
define process acao_baixo() { mover_nave(0.0, -0.16) }

// ============================================================================
// RENDERIZAÇÃO 3D COMPACTA (COCKPIT, TÚNEL, NAVES E PAINEL MARCODB)
// ============================================================================

define process renderizar_cena() {
    gui.limpar_tela("tela_3d")

    // 1. Moldura externa ajustada para altura 425
    gui.desenhar_retangulo("tela_3d", 6.0, 6.0, 934.0, 419.0, "", "#1E293B", 1)

    // 2. Desenha o Túnel 3D de Hiperespaço em movimento
    for each k in range(0, 3) {
        let z_anel = -0.4 + (to_float(k) * 1.05) - fase_tunel
        let cor_anel = k == 0 ? "#1E293B" : (k == 1 ? "#132038" : "#0B1324")
        for each seg in aneis_octogono {
            let p1 = [seg[0], seg[1], z_anel] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
            let p2 = [seg[2], seg[3], z_anel] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
            gui.desenhar_linha("tela_3d", p1[0], p1[1], p2[0], p2[1], cor_anel, 1)
        }
    }

    // Linhas longitudinais de velocidade no corredor 3D
    for each s in [-1.2, 1.2] {
        for each h in [-0.8, 0.8] {
            let pf = [s, h, 2.5] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
            let pn = [s, h, -0.9] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
            gui.desenhar_linha("tela_3d", pf[0], pf[1], pn[0], pn[1], "#0F172A", 1)
        }
    }

    // 3. Mira Holográfica 3D lá no fundo
    let p_mira = [nave_x, nave_y, 1.6] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    gui.desenhar_circulo("tela_3d", p_mira[0], p_mira[1], 12.0, "", "#00FFFF", 1)
    gui.desenhar_linha("tela_3d", p_mira[0] - 18.0, p_mira[1], p_mira[0] + 18.0, p_mira[1], "#00FFFF", 1)
    gui.desenhar_linha("tela_3d", p_mira[0], p_mira[1] - 18.0, p_mira[0], p_mira[1] + 18.0, "#00FFFF", 1)

    // 4. Desenha o Asteroide 3D (Octaedro Giratório Amarelo)
    let pa_c = [ast_x, ast_y, ast_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let rx_ast = math.cos(ast_rot) * 0.22
    let ry_ast = math.sin(ast_rot) * 0.22
    let pa_l = [ast_x - rx_ast, ast_y - ry_ast, ast_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pa_r = [ast_x + rx_ast, ast_y + ry_ast, ast_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pa_t = [ast_x, ast_y + 0.22, ast_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pa_b = [ast_x, ast_y - 0.22, ast_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    gui.desenhar_poligono("tela_3d", [pa_t, pa_r, pa_b, pa_l], "#422006", "#FACC15", 2)
    gui.desenhar_texto("tela_3d", pa_c[0], pa_t[1] - 9.0, "METEORO", "#FACC15", 8, "center")

    // 5. Desenha o Caça Inimigo 1 (Interceptor Vermelho Neon em 3D)
    let pi1_c = [inim1_x, inim1_y, inim1_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi1_l = [inim1_x - 0.26, inim1_y + 0.12, inim1_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi1_r = [inim1_x + 0.26, inim1_y + 0.12, inim1_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi1_b = [inim1_x, inim1_y - 0.16, inim1_z - 0.15] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    gui.desenhar_poligono("tela_3d", [pi1_l, pi1_r, pi1_b], "#4C0519", "#FF004D", 2)
    gui.desenhar_circulo("tela_3d", pi1_c[0], pi1_c[1], 4.0, "#FF004D", "#FFFFFF", 1)
    gui.desenhar_texto("tela_3d", pi1_c[0], pi1_l[1] - 9.0, "CAÇA MK-I", "#FF004D", 8, "center")

    // 6. Desenha o Caça Inimigo 2 (Cruzador Roxo/Rosa em 3D)
    let pi2_c = [inim2_x, inim2_y, inim2_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi2_l = [inim2_x - 0.26, inim2_y - 0.12, inim2_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi2_r = [inim2_x + 0.26, inim2_y - 0.12, inim2_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let pi2_t = [inim2_x, inim2_y + 0.16, inim2_z - 0.15] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    gui.desenhar_poligono("tela_3d", [pi2_l, pi2_r, pi2_t], "#3B0764", "#C084FC", 2)
    gui.desenhar_circulo("tela_3d", pi2_c[0], pi2_c[1], 4.0, "#C084FC", "#FFFFFF", 1)
    gui.desenhar_texto("tela_3d", pi2_c[0], pi2_t[1] - 9.0, "CRUZADOR", "#C084FC", 8, "center")

    // 7. Desenha Explosão 3D se houver impacto recente
    when flash_explosao > 0 {
        let p_exp = [exp_x, exp_y, exp_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        let r_exp = to_float(flash_explosao) * 5.5
        gui.desenhar_circulo("tela_3d", p_exp[0], p_exp[1], r_exp, "", "#FACC15", 2)
        gui.desenhar_circulo("tela_3d", p_exp[0], p_exp[1], r_exp * 0.5, "#FF007F", "#FFFFFF", 1)
    }

    // 8. Desenha os Feixes Duplos de Laser Plasma 3D
    when laser_ativo {
        let pl1_ini = [laser_x - 0.18, laser_y, laser_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        let pl1_fim = [laser_x - 0.12, laser_y, laser_z + 0.55] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        let pl2_ini = [laser_x + 0.18, laser_y, laser_z] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
        let pl2_fim = [laser_x + 0.12, laser_y, laser_z + 0.55] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

        gui.desenhar_linha("tela_3d", pl1_ini[0], pl1_ini[1], pl1_fim[0], pl1_fim[1], "#39FF14", 3)
        gui.desenhar_linha("tela_3d", pl2_ini[0], pl2_ini[1], pl2_fim[0], pl2_fim[1], "#39FF14", 3)
    }

    // 9. Desenha a Nave Espacial 3D do Jogador
    let dy_asa = nave_inclina * 0.25
    let p_bico = [nave_x, nave_y + 0.04, nave_z + 0.42] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_asa_esq = [nave_x - 0.34, nave_y - 0.08 + dy_asa, nave_z - 0.08] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_asa_dir = [nave_x + 0.34, nave_y - 0.08 - dy_asa, nave_z - 0.08] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_cauda = [nave_x, nave_y - 0.05, nave_z - 0.02] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)
    let p_topo = [nave_x, nave_y + 0.11, nave_z + 0.05] |> math3d.rotate_y(cam_yaw) |> math3d.rotate_x(cam_pitch) |> math3d.project_2d(310.0, 3.2, 550.0, 415.0)

    gui.desenhar_poligono("tela_3d", [p_bico, p_asa_esq, p_cauda], "#0F172A", "#00FFFF", 2)
    gui.desenhar_poligono("tela_3d", [p_bico, p_asa_dir, p_cauda], "#0F172A", "#00FFFF", 2)
    gui.desenhar_poligono("tela_3d", [p_bico, p_topo, p_cauda], "#1E293B", "#FF007F", 2)

    gui.desenhar_circulo("tela_3d", p_cauda[0] - 9.0, p_cauda[1] + 2.0, 4.0, "#FF007F", "#FACC15", 2)
    gui.desenhar_circulo("tela_3d", p_cauda[0] + 9.0, p_cauda[1] + 2.0, 4.0, "#FF007F", "#FACC15", 2)

    // Legenda ajustada para não invadir o painel direito
    gui.desenhar_texto("tela_3d", 18.0, 404.0, "Teclas: [W/A/S/D] Voar | [Espaço] Plasma | [G] Grover | [E] Escudo", "#94A3B8", 9, "left")

    // ========================================================================
    // 10. PAINEL DIREITO COMPACTO: COMPUTADOR DE BORDO & MARCODB LIVE RADAR
    // ========================================================================
    gui.desenhar_retangulo("tela_3d", 560.0, 14.0, 924.0, 412.0, "#070911", "#1E293B", 1)

    gui.desenhar_texto("tela_3d", 742.0, 32.0, "COMPUTADOR DE VOO // STAR-1", "#00FFFF", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 52.0, f"PONTOS: {pontos}  |  RECORDE: {recorde}", "#FACC15", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 70.0, f"Setor: {setor}  |  Combo: x{combo}  |  Abates: {abates}", "#39FF14", 9, "center")
    gui.desenhar_texto("tela_3d", 742.0, 88.0, f"Posição 3D: ({round(nave_x, 2)}, {round(nave_y, 2)}, {round(nave_z, 2)})", "#E2E8F0", 9, "center")

    // Barra 1: Escudo Defletor da Nave
    gui.desenhar_texto("tela_3d", 576.0, 110.0, f"Escudo Defletor do Casco: {round(escudo, 0)}%", "#00FFFF", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 120.0, 906.0, 133.0, "#1E293B", "#334155", 1)
    let larg_esc = (escudo / 100.0) * 330.0
    when larg_esc > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 120.0, 576.0 + larg_esc, 133.0, "#00FFFF", "#00FFFF", 1)
    }

    // Barra 2: Energia dos Canhões de Plasma
    gui.desenhar_texto("tela_3d", 576.0, 147.0, f"Energia dos Canhões de Plasma: {round(energia_armas, 0)}%", "#39FF14", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 157.0, 906.0, 170.0, "#1E293B", "#334155", 1)
    let larg_arm = (energia_armas / 100.0) * 330.0
    when larg_arm > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 157.0, 576.0 + larg_arm, 170.0, "#39FF14", "#39FF14", 1)
    }

    // Barra 3: Bomba Quântica de Grover
    gui.desenhar_texto("tela_3d", 576.0, 184.0, f"Bomba Quântica de Grover [G]: {round(carga_warp, 0)}%", "#FF007F", 9, "left")
    gui.desenhar_retangulo("tela_3d", 576.0, 194.0, 906.0, 207.0, "#1E293B", "#334155", 1)
    let larg_wp = (carga_warp / 100.0) * 330.0
    when larg_wp > 1.0 {
        gui.desenhar_retangulo("tela_3d", 576.0, 194.0, 576.0 + larg_wp, 207.0, "#FF007F", "#FF007F", 1)
    }

    // Seção MarcoDB Radar 3D
    gui.desenhar_linha("tela_3d", 576.0, 220.0, 906.0, 220.0, "#1E293B", 1)
    gui.desenhar_texto("tela_3d", 742.0, 235.0, "RADAR ESPACIAL 3D // MARCODB", "#FF007F", 10, "center")
    gui.desenhar_texto("tela_3d", 742.0, 254.0, f"Sistema: {ultima_acao}", "#E2E8F0", 9, "center")
    gui.desenhar_texto("tela_3d", 742.0, 272.0, f"Alvo Hostil Mais Próximo: {round(dist_radar, 2)} u.a.", "#39FF14", 9, "center")

    let st = db.stats()
    let n_docs = "documents" in st ? st["documents"] : (abates + 2)
    let v_mvcc = "mvcc_version" in st ? st["mvcc_version"] : (abates + 2)
    gui.desenhar_texto("tela_3d", 742.0, 290.0, f"Logs MQL: {n_docs} | MVCC v{v_mvcc} | CRC32: OK", "#00FFFF", 9, "center")

    // Top 3 Pilotos via MQL
    gui.desenhar_texto("tela_3d", 742.0, 312.0, "🏆 TOP ESQUADRÃO MQL (SELECT ORDER BY):", "#FACC15", 9, "center")
    let top_pilotos = db.query("SELECT * FROM ranking ORDER BY pontos DESC LIMIT 3")
    let y_rank = 330.0
    let pos_rk = 1
    for each reg in top_pilotos {
        let linha_rk = f"{pos_rk}. {reg['piloto']} -> {reg['pontos']} pts (Setor {reg['setor']})"
        gui.desenhar_texto("tela_3d", 742.0, y_rank, linha_rk, "#CBD5E1", 9, "center")
        y_rank += 17.0
        pos_rk += 1
    }

    when game_over {
        gui.desenhar_retangulo("tela_3d", 80.0, 155.0, 480.0, 265.0, "#090A0F", "#FF004D", 2)
        gui.desenhar_texto("tela_3d", 280.0, 188.0, "💥 NAVE DESTRUÍDA EM COMBATE!", "#FF004D", 13, "center")
        gui.desenhar_texto("tela_3d", 280.0, 216.0, f"Pontuação Final: {pontos} pts | Abates: {abates}", "#FFFFFF", 10, "center")
        gui.desenhar_texto("tela_3d", 280.0, 240.0, "Pressione [G] ou [R] para Reiniciar a Missão", "#39FF14", 9, "center")
    }

    gui.desenhar_texto("tela_3d", 742.0, 396.0, "Clique ou arraste na tela 3D para guiar e disparar", "#C084FC", 8, "center")
}

// ============================================================================
// LOOP FÍSICO E DE COLISÃO 3D EM TEMPO REAL (30 FPS)
// ============================================================================

define process loop_jogo() {
    when not game_over {
        let vel_cenario = 0.075 + (to_float(setor) * 0.012)
        fase_tunel += vel_cenario
        when fase_tunel >= 1.05 {
            fase_tunel -= 1.05
        }

        ast_rot += 0.14
        nave_inclina *= 0.80
        energia_armas = math.clamp(energia_armas + 0.9, 0.0, 100.0)

        inim1_z -= vel_cenario
        inim2_z -= (vel_cenario * 1.1)
        ast_z -= (vel_cenario * 0.95)

        when laser_ativo {
            laser_z += 0.38
            let pos_laser = [laser_x, laser_y, laser_z]

            let hit1 = math3d.dist3d(pos_laser, [inim1_x, inim1_y, inim1_z])
            let hit2 = math3d.dist3d(pos_laser, [inim2_x, inim2_y, inim2_z])
            let hit_ast = math3d.dist3d(pos_laser, [ast_x, ast_y, ast_z])

            when hit1 < 0.48 {
                laser_ativo = false
                registrar_abate(120, "Caça MK-I", inim1_x, inim1_y, inim1_z)
                spawn_inimigo1()
            } else when hit2 < 0.48 {
                laser_ativo = false
                registrar_abate(150, "Cruzador", inim2_x, inim2_y, inim2_z)
                spawn_inimigo2()
            } else when hit_ast < 0.48 {
                laser_ativo = false
                registrar_abate(90, "Meteoro", ast_x, ast_y, ast_z)
                spawn_asteroide()
            }

            when laser_z > 2.9 {
                laser_ativo = false
            }
        }

        let pos_nave = [nave_x, nave_y, nave_z]
        let d1 = math3d.dist3d(pos_nave, [inim1_x, inim1_y, inim1_z])
        let d2 = math3d.dist3d(pos_nave, [inim2_x, inim2_y, inim2_z])
        let d3 = math3d.dist3d(pos_nave, [ast_x, ast_y, ast_z])

        dist_radar = d1 < d2 ? d1 : d2

        when d1 < 0.42 {
            escudo = math.clamp(escudo - 22.0, 0.0, 100.0)
            combo = 1
            flash_explosao = 5
            exp_x = inim1_x
            exp_y = inim1_y
            exp_z = inim1_z
            msg_hud = "⚠️ IMPACTO DIRETO COM CAÇA MK-I! Escudo danificado (-22%)!"
            spawn_inimigo1()
        }

        when d2 < 0.42 {
            escudo = math.clamp(escudo - 25.0, 0.0, 100.0)
            combo = 1
            flash_explosao = 5
            exp_x = inim2_x
            exp_y = inim2_y
            exp_z = inim2_z
            msg_hud = "⚠️ COLISÃO COM CRUZADOR HOSTIL! Escudo danificado (-25%)!"
            spawn_inimigo2()
        }

        when d3 < 0.42 {
            escudo = math.clamp(escudo - 18.0, 0.0, 100.0)
            combo = 1
            flash_explosao = 5
            exp_x = ast_x
            exp_y = ast_y
            exp_z = ast_z
            msg_hud = "⚠️ COLISÃO COM METEORO! Desvie das rochas espaciais (-18%)!"
            spawn_asteroide()
        }

        when inim1_z < -1.1 {
            spawn_inimigo1()
        }
        when inim2_z < -1.1 {
            spawn_inimigo2()
        }
        when ast_z < -1.1 {
            spawn_asteroide()
        }

        when escudo <= 0.0 {
            game_over = true
            msg_hud = f"💥 FIM DE MISSÃO! Pontuação gravada no MarcoDB: {pontos} pts."
        }
    }

    when flash_explosao > 0 {
        flash_explosao -= 1
    }

    gui.alterar_texto("lbl_status", msg_hud)
    renderizar_cena()
    gui.agendar_atualizacao(35, "loop_jogo")
}

// ============================================================================
// CONTROLES DE MOUSE E TECLADO (EIXO Y CORRIGIDO: CIMA = +Y, BAIXO = -Y)
// ============================================================================

define process ao_clicar_mouse(x: int, y: int) {
    when x < 550 {
        nave_x = math.clamp((to_float(x) - 275.0) / 160.0, -1.15, 1.15)
        nave_y = math.clamp((207.0 - to_float(y)) / 150.0, -0.78, 0.78)
        cam_yaw = nave_x * 0.12
        disparar_laser()
    }
}

define process ao_arrastar_mouse(x: int, y: int) {
    when x < 550 {
        nave_x = math.clamp((to_float(x) - 275.0) / 160.0, -1.15, 1.15)
        nave_y = math.clamp((207.0 - to_float(y)) / 150.0, -0.78, 0.78)
        cam_yaw = nave_x * 0.12
        disparar_laser()
    }
}

define process ao_teclar(tecla: string) {
    match tecla {
        case "a", "A", "Left" => mover_nave(-0.18, 0.0)
        case "d", "D", "Right" => mover_nave(0.18, 0.0)
        case "w", "W", "Up" => mover_nave(0.0, 0.16)
        case "s", "S", "Down" => mover_nave(0.0, -0.16)
        case "space", "Return", "f", "F" => disparar_laser()
        case "g", "G" => ativar_bomba_quantica()
        case "e", "E" => ativar_turbo_escudo()
        case "r", "R" => reiniciar_jogo()
    }
}

// ============================================================================
// CONSTRUÇÃO DA JANELA COMPACTA (960x610) E PAINEL DE COMANDO (HUD)
// ============================================================================

gui.criar_janela("Star Interceptor 3D // Combate Espacial + MarcoDB", "960x610", "#050508")

gui.criar_rotulo("lbl_titulo", "🚀 STAR INTERCEPTOR 3D // CORREDOR DE HIPERESPAÇO & RADAR MARCODB", "#00FFFF", "#050508", 11)
gui.criar_tela("tela_3d", 940, 425, "#050508")
gui.criar_rotulo("lbl_status", msg_hud, "#39FF14", "#050508", 10)

// Linha 1: Manobras 3D e Disparo de Plasma
gui.iniciar_linha(8, "#050508")
gui.criar_botao("btn_esq", "⬅️ Manobra Esq [A]", acao_esq, "#161B26", "#00FFFF")
gui.criar_botao("btn_cima", "⬆️ Subir [W]", acao_cima, "#161B26", "#39FF14")
gui.criar_botao("btn_baixo", "⬇️ Mergulhar [S]", acao_baixo, "#161B26", "#39FF14")
gui.criar_botao("btn_dir", "➡️ Manobra Dir [D]", acao_dir, "#161B26", "#00FFFF")
gui.criar_botao("btn_tiro", "🔫 Disparar Plasma [Espaço]", disparar_laser, "#161B26", "#FACC15")
gui.encerrar_linha()

// Linha 2: Sistemas Especiais Quânticos
gui.iniciar_linha(10, "#050508")
gui.criar_botao("btn_warp", "⚛️ Bomba Quântica Grover [G]", ativar_bomba_quantica, "#161B26", "#FF007F")
gui.criar_botao("btn_escudo", "🛡️ Recarregar Escudo [E]", ativar_turbo_escudo, "#161B26", "#C084FC")
gui.criar_botao("btn_reset", "🔁 Reiniciar Missão [R]", reiniciar_jogo, "#161B26", "#94A3B8")
gui.encerrar_linha()

// Eventos de Mouse e Teclado
gui.vincular_evento_rato("tela_3d", "clique", ao_clicar_mouse)
gui.vincular_evento_rato("tela_3d", "arrastar", ao_arrastar_mouse)
gui.vincular_evento_teclado(ao_teclar)

loop_jogo()
gui.iniciar_loop()
LUCIDA-FLOW v2.0 & LUCIDA-FLOW STUDIO — Desenvolvido por QOrigin // SoteroApps
↑ Topo Playground ● CRC32 DOCS: OK