VORGS
LAB SIMULATOR

// ✅ BOM — MonoBehaviour apenas como thin wrapper de rendering
public sealed class OrganismRendererMono : MonoBehaviour
{
    [SerializeField] private Renderer _renderer;
    [SerializeField] private Transform _root;

    private IOrganismRenderService _renderService;  // injetado via VContainer
    private CompositeDisposable _disposables = new();

    [Inject]
    public void Construct(IOrganismRenderService renderService)
        => _renderService = renderService;

    private void Start()
    {
        _renderService.OnPhenotypeChanged
            .Subscribe(ApplyPhenotype)
            .AddTo(_disposables);
    }

    private void ApplyPhenotype(Phenotype phenotype)
    {
        // apenas manipula componentes Unity — zero lógica de domínio aqui
        _renderer.material.SetColor("_BaseColor", phenotype.Color);
        _renderer.material.SetFloat("_EmissionIntensity", phenotype.LightEmission);
        _root.localScale = Vector3.one * phenotype.Scale;
    }

    private void OnDestroy() => _disposables.Dispose();
}

[BurstCompile]
public struct TranslateGenomeJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<Nucleotide> Genome;
    public NativeArray<AminoAcid> Proteins;

    public void Execute(int index)
    {
        // Cálculo direto e otimizado com Burst, sem ECS overhead
        var codon = GetCodonAt(index);
        Proteins[index] = Translate(codon);
    }
}

// Rigging procedimental com cinemática inversa (IK) para feedback visual
public sealed class RoboticArmMono : MonoBehaviour
{
    [SerializeField] private TwoBoneIKConstraint _armConstraint;
    [SerializeField] private Transform _effectorTarget;
    [SerializeField] private ParticleSystem _injectorMist;
    [SerializeField] private LineRenderer _laserRenderer;

    public async UniTask PerformInjectionAsync(Vector3 fluidPosition, CancellationToken ct)
    {
        // Move proceduralmente a ponta da agulha até a superfície da água
        await MoveTargetToAsync(fluidPosition, 1.5f, ct);
        _injectorMist.Play();
        await UniTask.Delay(1000, cancellationToken: ct);
        await RetractArmAsync(ct);
    }

    public async UniTask PerformRadiationAsync(Vector3 targetPosition, CancellationToken ct)
    {
        await MoveTargetToAsync(targetPosition + Vector3.up * 0.5f, 1.0f, ct);
        _laserRenderer.enabled = true;
        // Ativa feixe UV e partículas de radiação
        await UniTask.Delay(2000, cancellationToken: ct);
        _laserRenderer.enabled = false;
        await RetractArmAsync(ct);
    }

    private async UniTask MoveTargetToAsync(Vector3 pos, float duration, CancellationToken ct) { /* Lerp do _effectorTarget.position */ }
    private async UniTask RetractArmAsync(CancellationToken ct) { /* Retorna _effectorTarget à pose inicial */ }
}

public sealed class SequencerViewModel : IDisposable
{
    // Observable properties — a View se subscreve, nunca puxa
    public ReadOnlyReactiveProperty<string> NucleotideSequence { get; }
    public ReadOnlyReactiveProperty<bool>   IsSequencing       { get; }
    public Observable<ProteinData>          OnProteinDiscovered { get; }

    private readonly ReactiveProperty<string> _sequence    = new();
    private readonly ReactiveProperty<bool>   _isSequencing = new(false);
    private readonly Subject<ProteinData>     _proteinFound = new();
    private readonly CompositeDisposable     _disposables  = new();

    public SequencerViewModel(IGeneticsService genetics, Genome target)
    {
        NucleotideSequence = _sequence.ToReadOnlyReactiveProperty();
        IsSequencing       = _isSequencing.ToReadOnlyReactiveProperty();
        OnProteinDiscovered = _proteinFound;

        _sequence.Value = target.Nucleotides;
    }

    public async UniTaskVoid SequenceAsync(Genome genome, CancellationToken ct)
    {
        _isSequencing.Value = true;
        // ... lógica de sequenciamento com delay por upgrade de equipamento
        _isSequencing.Value = false;
    }

    public void Dispose() => _disposables.Dispose();
}

// View — 100% passiva, zero lógica de negócio, zero dependências de domínio
public sealed class SequencerView : IDisposable
{
    private readonly Label               _sequenceLabel;
    private readonly ProgressBar         _progressBar;
    private readonly CompositeDisposable _disposables = new();

    public SequencerView(VisualElement root)
    {
        _sequenceLabel = root.Q<Label>("sequence-label");
        _progressBar   = root.Q<ProgressBar>("progress-bar");
    }

    public void Bind(SequencerViewModel vm)
    {
        vm.NucleotideSequence
            .Subscribe(seq => _sequenceLabel.text = seq)
            .AddTo(_disposables);

        vm.IsSequencing
            .Subscribe(active => _progressBar.SetVisible(active))
            .AddTo(_disposables);

        vm.OnProteinDiscovered
            .Subscribe(PlayDiscoveryAnimation)
            .AddTo(_disposables);
    }

    private void PlayDiscoveryAnimation(ProteinData p) { /* USS animation class toggle */ }

    public void Dispose() => _disposables.Dispose();
}

public sealed class AppScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        // ── Infrastructure ──────────────────────────────────────────
        builder.Register<ISaveRepository, JsonSaveRepository>(Lifetime.Singleton);
        builder.Register<ICloudRepository, FirebaseRepository>(Lifetime.Singleton);
        builder.Register<IEventBus, R3EventBus>(Lifetime.Singleton);

        // ── ECS Bridge ───────────────────────────────────────────────
        builder.Register<IGenomeBridge, GenomeBridge>(Lifetime.Singleton);

        // ── Domain Services ──────────────────────────────────────────
        builder.Register<ITranslationService, CodonTranslationService>(Lifetime.Singleton);
        builder.Register<IGeneticsService, GeneticsService>(Lifetime.Singleton);
        builder.Register<IMutationService, MutationService>(Lifetime.Singleton);
        builder.Register<IEconomyService, EconomyService>(Lifetime.Singleton);
        builder.Register<IPatentService, PatentService>(Lifetime.Singleton);
    }
}

// LifetimeScope por cena — herda AppScope
public sealed class SequencerScope : LifetimeScope
{
    protected override void Configure(IContainerBuilder builder)
    {
        builder.Register<SequencerViewModel>(Lifetime.Scoped);
        builder.RegisterComponentInHierarchy<SequencerController>();
    }
}

{
  "version": "1.0.0",
  "savedAt": "2025-11-01T14:32:00Z",
  "lab": {
    "funds": 14200,
    "aquariums": [
      {
        "id": "aq_01",
        "biome": "TROPICAL",
        "genomeCrc32": "a3f8c21d",  // checksum de integridade
        "nucleotides": "ATGCGATCGATCGTACGATCG..."
      }
    ]
  },
  "discoveredNodes": ["node_luciferase", "node_transport_mineral"],
  "patents": [
    {
      "pathId": "path_biolum_v1",
      "registeredAt": "2025-11-01T10:00:00Z",
      "genomeBase64": "QVRHQ0dBVENHQVRDR1RBQ0dBVENH..."
    }
  ]
}

public sealed class JsonSaveRepository : ISaveRepository
{
    private static readonly JsonSerializerSettings _settings = new()
    {
        Converters        = { new NucleotideConverter() },
        Formatting        = Formatting.Indented,
        NullValueHandling = NullValueHandling.Ignore
    };

    public async UniTask<Result<SaveData>> LoadAsync(int slot, CancellationToken ct)
    {
        var path = GetSlotPath(slot);
        if (!File.Exists(path))
            return Result<SaveData>.Fail("Save not found");

        var json = await File.ReadAllTextAsync(path, ct);
        var data = JsonConvert.DeserializeObject<SaveData>(json, _settings);

        // valida integridade de cada genoma pelo CRC32
        foreach (var aq in data.Lab.Aquariums)
            if (!ValidateChecksum(aq))
                return Result<SaveData>.Fail($"Genome checksum mismatch: {aq.Id}");

        return Result<SaveData>.Ok(data);
    }
}

[NodeMenuItem("Metabolism/Enzyme")]
public class EnzymeNode : BaseNode
{
    [Input("Substrate")]  public SubstrateData substrate;
    [Output("Product")]   public SubstrateData product;

    [SerializeField] public string  enzymeName;
    [SerializeField] public float   kineticRate;
    [SerializeField] public float   energyCost;   // ATP equivalentes
    [SerializeField] public string  requiredCodon; // códon que gera essa enzima

    public override string name => enzymeName;

    protected override void Process()
    {
        product = new SubstrateData
        {
            Id           = substrate.Id + "_processed",
            Concentration = substrate.Concentration * kineticRate
        };
    }
}

export const generateWildGenome = onCall(async (request) => {
  const { biomeId, playerLevel } = request.data;

  // RNG server-side — cliente nunca acessa a semente
  const seed   = crypto.randomBytes(16).toString("hex");
  const rarity = rollRarity(playerLevel, seed);

  const genome = await buildGenomeForBiome({
    biomeId,
    rarity,
    seed,
    codonTable: await getCodonTableForBiome(biomeId)
  });

  return {
    nucleotides: genome.nucleotides,
    rarity:      rarity,
    checksum:    crc32(genome.nucleotides),   // validação pelo cliente
    expiresAt:   Date.now() + 3600000           // 1h para aceitar
  };
});