🌌 Lucida-flow Studio & Qorigin Hub

Documentação Oficial do Desenvolvedor | Versão 1.0
Copyright © 2026 SoteroApps / Qorigin

O ecossistema Qorigin é composto por duas partes fundamentais: a Lucida-Flow, uma linguagem de programação estruturada, tipada dinamicamente e orientada a objetos; e o Lucida-flow Studio, uma IDE de nível industrial com renderização nativa, autocompletar e compilação direta para executáveis (.exe).

🖥️ 1. O Ambiente: Lucida-flow Studio

A IDE foi projetada para fluxo contínuo de trabalho (Flow), isolando a interface gráfica da execução de código para evitar travamentos (crashes).

Recursos da Interface

Workspaces: Gerenciamento de projetos em pastas com árvore de arquivos (QTreeView). O estado do workspace (arquivos abertos) é salvo automaticamente no .qorigin_workspace.json.
Motor de Temas Dinâmico: Personalização de cores em tempo real (Cyberpunk, Matrix, Tron, Alerta, Void) e controle de escalonamento de fonte para acessibilidade.
IntelliSense (Autocompletar): Sugestões de código em tempo real, abrangendo todas as palavras reservadas, built-ins e módulos da biblioteca padrão (ex: math3d, qbit, gui).

Atalhos de Execução e Compilação

Atalho / Botão	Ação	Descrição
`F5`	Rodar no Console	Executa o código em modo texto no terminal integrado. Suporta inputs interativos (`read`).
`F6`	Rodar Interface Gráfica	Lança o renderizador de UI em uma thread paralela isolada.
`Shift` + `F5`	Sniper (Stop)	Aborta forçadamente qualquer execução em andamento (loop infinito ou travamento).
`Ctrl` + `S`	Salvar	Salva o documento atual.
Botão ⚙	Compilar	Exporta o projeto atual para um Executável Windows (`.exe`), permitindo escolher entre modo Console ou Janela Oculta (GUI).

📜 2. A Linguagem: Lucida-Flow

2.1. Variáveis e Tipagem Híbrida

A linguagem possui tipagem forte, mas alocação dinâmica. O operador + é sobrecarregado para concatenar strings automaticamente de forma segura.
Tipos suportados: int, float, string, bool, null, list (Arrays), dict (Dicionários) e tuple.

let nome = "Prism Engine"
const versao = 1.0
let ativo = true

// O compilador entende e converte os números para string automaticamente
print("O " + nome + " está na versão " + versao)

2.2. Estruturas de Dados

Suporte nativo a listas (Arrays) e dicionários com métodos embutidos.

let inimigos = ["Orc", "Troll", "Goblin"]
inimigos.append("Dragão")

let config = { "resolucao": "1080p", "vsync": true }

2.3. Controle de Fluxo (Condicionais e Loops)

A linguagem utiliza when no lugar do tradicional "if", trazendo uma semântica orientada a eventos.

// Preparando os dados para o exemplo
let energia = 15
let inimigos = ["Orc", "Goblin", "Troll"]
let ativo = false

define process alerta_critico() {
    print("Alerta: Energia crítica!")
}

define process manter_rota() {
    print("Sistemas normais. Rota mantida.")
}

// Condicionais
when (energia < 20) {
    alerta_critico()
} otherwise {
    manter_rota()
}

// Loop - For Each
for each inimigo in inimigos {
    print("Inimigo detectado: " + inimigo)
}

// Loop - While
while (ativo == true) {
    print("Sistema ativo...")
    ativo = false // Evita loop infinito no exemplo
}

2.4. Funções (Processos)

Blocos de código reutilizáveis são definidos como process.

// Preparando os dados
let ataque = 50
let defesa = 20

define process calcular_dano(ataque, defesa) {
    let dano_final = ataque - defesa
    print("Dano causado: " + dano_final)
}

// Chamando o processo
calcular_dano(ataque, defesa)

2.5. Orientação a Objetos (OOP)

A Lucida-Flow suporta encapsulamento e instanciamento de objetos usando a keyword type.

// Em Lucida-Flow, você pode usar Dicionários para criar entidades dinâmicas
let jogador = {
    "nome": "Marco",
    "hp": 100
}

// Criamos um processo que recebe a entidade e altera seus dados
define process receber_dano(alvo, valor) {
    alvo["hp"] = alvo["hp"] - valor
    print(alvo["nome"] + " recebeu dano! HP atual: " + alvo["hp"])
}

// Testando a lógica de combate
print("Iniciando batalha...")
receber_dano(jogador, 15)
receber_dano(jogador, 25)

2.6. Resiliência: Try/Catch/Finally

Sistema avançado de captura de exceções baseada em Activation Records. Evita o crash da aplicação tratando os erros em tempo de execução.

// Preparando uma simulação para o exemplo
define process conectar_banco() {
    print("Conectando ao banco de dados...")
    // Aqui aconteceria a lógica de conexão que pode falhar
}

// Exemplo de Tratamento de Erros (Try / Catch / Finally)
try {
    conectar_banco()
    print("Operação concluída com sucesso!")
} catch (erro: Exception) {
    print("Falha detectada: " + erro)
} finally {
    print("Bloco de execução encerrado. Limpando memória...")
}

📦 3. Biblioteca Padrão (Standard Library)

A Lucida-Flow já vem com baterias inclusas. Abaixo estão os módulos nativos (acessados via import "nome_modulo" as apelido).

🖥️ Módulo: gui (Interface Gráfica e Canvas)

Responsável por renderizar o sistema de janelas nativo do sistema operacional.

Função	Parâmetros	Descrição
`criar_janela`	`id, resolucao`	Instancia a janela principal (Ex: "App", "800x600").
`criar_rotulo`	`id, texto`	Cria um texto simples na tela.
`criar_botao`	`id, texto, callback`	Cria um botão que aciona um `process` ao ser clicado.
`criar_entrada`	`id`	Cria uma caixa de input de linha única.
`criar_caixa_texto`	`id`	Cria um bloco de texto multilinhas.
`criar_slider`	`id, min, max`	Cria um controle deslizante numérico.
`criar_checkbox`	`id, texto`	Cria uma caixa de marcação booleana (0 ou 1).
`criar_lista`	`id`	Cria um componente de lista com rolagem (Componente Dinâmico).
`criar_tela`	`id, w, h, cor`	Cria um Canvas para renderização 2D.
`desenhar_linha`	`id, x1, y1, x2, y2, cor`	Traça uma linha no Canvas 2D.
`vincular_evento_rato`	`id, evento, callback`	Captura cliques e movimento do mouse passando X e Y.
`agendar_atualizacao`	`ms, callback`	Cria um loop recursivo assíncrono (Timer).

🧮 Demais Módulos de Sistema

math e math3d: Cálculos avançados e simulação vetorial. (pi, sqrt, soma, dist2d, dot, cross, normalize).
fs (File System): write, read, exists, delete.
json: parse, stringify.
time & datetime: now, format, parse.
web: get (Consumo de APIs externas).
Jogos e Simulação (media & dado): dado.d6, dado.rolar_entre (RNG nativo). Sistema completo de áudio (carregar, tocar, pausar, parar).
Simulação Quântica (qbit): Portas lógicas quânticas nativas. (h_gate, x_gate, measure).

💡 4. Exemplo Mestre: O Poder da Lucida-Flow

Este exemplo demonstra a criação de uma interface gráfica complexa, usando loops e a manipulação de componentes dinâmicos de forma limpa e concisa.

import "gui" as tela
import "time" as relogio

tela.criar_janela("Painel Prism Engine", "600x400")
tela.criar_rotulo("titulo", "INSPETOR DE ENTIDADES")

// Popula uma lista dinamicamente
let entidades = ["Player", "Inimigo_1", "Boss_Final", "Caixa_Fisica"]
tela.criar_lista("lista_objetos")

// Loop corrigido: sem parênteses
for each obj in entidades {
    tela.adicionar_item_lista("lista_objetos", obj)
}

tela.criar_botao("btn_analisar", "INSPECIONAR", "analisar")
tela.criar_rotulo_resultado("log", "Aguardando...")

define process analisar() {
    let alvo = tela.obter_selecao_lista("lista_objetos")
    let hora = relogio.now()
    
    when (alvo != "") {
        tela.alterar_texto("log", "[" + hora + "] Inspecionando: " + alvo)
    } otherwise {
        tela.alterar_texto("log", "Erro: Nenhuma entidade selecionada.")
    }
}

// Inicia a renderização
tela.iniciar_loop()

SoteroApps - Desenvolvendo as fundações de amanhã, hoje.

⚡ Lucida Docs