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 VISUALPRONTO
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.1Pipeline 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 Protocolo
Abre uma nova aba com realce de sintaxe e autocompletar inteligente.
Ctrl + O / Ctrl + S
⇪ Carregar / ⭳ Salvar
Abre ou salva arquivos .lf em UTF-8 com monitoramento de modificação (●).
F5
▶ Executar
Roda scripts de console na thread interna ou abre apps gui via processo isolado --runner.
Shift + F5
🛑 Parar Sistema
Interrompe imediatamente loops infinitos, leituras de input ou janelas gráficas.
⚙ Compilar (.EXE/.APP)
📦 Empacotar Binário
Empacota a AST validada + runtime e módulos nativos em executável autônomo sem dependências externas.
Ctrl + L
🧹 Limpar Terminal
Limpa o histórico visual do console interativo REPL.
1.2Regras 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.3Sistema 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.4Operadores 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 ~x
Uná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 not
Comparaçã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 / 12
and | or
E 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.
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.2Pattern 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.3Laç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.1Fatiamento 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.2Referência Completa de Métodos Nativos (string, list, dict & Builtins)
.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.1Declaraçã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.2Programaçã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())
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.3Gerador Estocástico/RPG (dado) e Sintetizador de Áudio (media)
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.1Pilha 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.2Catálogo Completo de Funções do Módulo gui
Categoria
Assinatura da Função
Descrição Técnica
Janela & Loop
gui.criar_janela(titulo, [geom], [bg])
Inicializa a janela principal nativa (ex: "800x600", "#090A0F").
Janela & Loop
gui.iniciar_loop() / gui.fechar_janela()
Inicia o event-loop gráfico principal ou encerra a aplicação com segurança.
Containers
gui.iniciar_linha([esp], [bg]) / encerrar_linha()
Empilha e fecha um container horizontal para posicionar widgets lado a lado.
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 / list
Produto escalar ($\vec{a}\cdot\vec{b}$) e produto vetorial ortogonal ($\vec{a}\times\vec{b}$).
math3d.magnitude(v) / normalize(v)
float / list
Norma euclidiana $\|\vec{v}\|$ e normalização para vetor unitário.
math3d.distance(a, b) / angle_between(a, b)
float
Distância 3D entre pontos e ângulo em radianos entre dois vetores.
math3d.rotate_x(v, rad) / rotate_y / rotate_z
list [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.
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.2Simulador 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:
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.1Operaçõ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.2Busca Vetorial HNSW (IA), Busca Textual BM25 e Índice Espacial 3D
Ranking probabilístico de relevância textual Okapi BM25.
Espacial 3D & Cripto
spatial_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 OFICIAL4 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.
🖩 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()