5.2 KiB
🌍 Garantias de Portabilidade e Execução Multiplataforma
1. Visão Geral
PROMETEU foi projetado desde o início para ser portável por construção, não por adaptação posterior.
Um cartucho PROMETEU:
- executa da mesma forma em qualquer plataforma suportada
- produz os mesmos resultados para as mesmas entradas
- mantém comportamento técnico previsível
PROMETEU não depende da plataforma. A plataforma depende do PROMETEU.
Este capítulo define o contrato de portabilidade do sistema.
2. Princípio Fundamental da Portabilidade
A portabilidade em PROMETEU se baseia em uma regra simples:
Somente a PROMETEU VM define o comportamento do programa.
Isso significa:
- linguagens-fonte não importam após compilação
- hardware real não influencia lógica
- sistema operacional não altera semântica
Tudo que não pertence à VM é adaptação, não execução.
3. Separação de Responsabilidades
PROMETEU separa rigorosamente três camadas:
+----------------------------+
| CARTUCHO |
| (bytecode + assets) |
+-------------+--------------+
|
+-------------v--------------+
| PROMETEU VM |
| (lógica, tempo, memória) |
+-------------+--------------+
|
+-------------v--------------+
| CAMADA DE PLATAFORMA |
| janela, áudio,input, FS |
+----------------------------+
O que a VM controla
- execução de bytecode
- tempo lógico (frames, ciclos)
- memória (stack, heap)
- determinismo
- custos e métricas
O que a plataforma fornece
- exibição de pixels
- saída de áudio
- coleta de input físico
- acesso ao sistema de arquivos sandbox
A plataforma nunca decide comportamento.
4. Determinismo como Base da Portabilidade
PROMETEU garante determinismo por meio de:
- clock lógico fixo (60 Hz)
- ciclos abstratos, não tempo real
- input amostrado por frame
- ausência de concorrência implícita
- ausência de operações dependentes de sistema
Isso permite afirmar:
“Se o cartucho é o mesmo, o jogo é o mesmo.”
5. Independência de Hardware Real
PROMETEU não utiliza:
- timers do sistema operacional
- clocks de alta resolução
- instruções específicas de CPU
- aceleração gráfica não controlada
Todo desempenho é medido em ciclos PROMETEU, não em milissegundos.
O hardware real:
- apenas executa a VM
- nunca interfere na semântica
6. Precisão de Ponto Flutuante
Para garantir consistência numérica:
- PROMETEU define operações matemáticas explícitas
- evita dependência de FPU específica
- padroniza comportamento de
number
Isso evita:
- divergências entre arquiteturas
- erros acumulativos imprevisíveis
- diferenças sutis entre plataformas
7. Input Multiplataforma
PROMETEU abstrai input físico em estado lógico.
- teclado, gamepad e toque são mapeados externamente
- o cartucho só enxerga botões e eixos lógicos
- o momento da leitura é fixo por frame
O mesmo cartucho:
- reage da mesma forma em PC, mobile ou console
- não contém lógica dependente de dispositivo
8. Áudio Multiplataforma
O sistema de áudio:
- define canais e mixagem logicamente
- usa APIs nativas apenas como saída
- mantém sincronização por frame
Diferenças de hardware:
- não alteram timing lógico
- não alteram sequência sonora
- não afetam certificação
9. Gráficos Multiplataforma
O sistema gráfico:
- opera sobre framebuffer lógico
- usa paleta indexada
- não depende de GPU específica
A camada de plataforma:
- apenas exibe o framebuffer
- não reinterpreta comandos gráficos
PROMETEU não delega decisões gráficas ao hardware.
10. Sistema de Arquivos e Persistência
PROMETEU define um filesystem lógico sandbox:
- caminhos virtuais
- limites de tamanho
- comportamento determinístico
A plataforma mapeia esse filesystem para:
- disco
- storage móvel
- memória persistente
Sem alterar semântica.
11. Certificação e Portabilidade
A Certificação PROMETEU é válida para todas as plataformas.
Se um cartucho:
- passa em uma plataforma
- com as mesmas entradas
Ele:
- passará em todas
- produzirá os mesmos relatórios
Isso é possível porque:
a certificação valida a VM, não o ambiente.
12. O que PROMETEU NÃO garante
PROMETEU não promete:
- desempenho absoluto igual (FPS real)
- latência física idêntica
- consumo energético equivalente
PROMETEU promete:
- comportamento lógico idêntico
- decisões técnicas reproduzíveis
13. Implicações Pedagógicas
Este modelo permite ensinar:
- diferença entre lógica e apresentação
- por que engines modernas quebram determinismo
- como isolar sistemas
- como projetar software portável
O aluno aprende:
portabilidade não é sorte — é arquitetura.
14. Resumo
- PROMETEU define comportamento na VM
- plataformas apenas executam
- tempo é lógico, não físico
- input, áudio e gráficos são abstraídos
- certificação é universal
- portabilidade é garantida por design