FluxManager

Resumen

Imova.Flux.FluxManager es un MonoBehaviour y singleton (public static FluxManager Instance). Es el orquestador central del Sistema de Flujos Imova: mantiene la lista de secuencias cargadas, controla cuál está activa, delega el comportamiento de avance de pasos al FluxState activo, y expone el conjunto de eventos estáticos que el resto del sistema (UI, componentes de escena, analítica) usa para reaccionar a cambios de estado de la secuencia en ejecución.

Cuándo usarla

Es el punto de entrada principal para cualquier desarrollador que integre el sistema de flujos en una escena: para cargar secuencias (desde Firebase o localmente), iniciarlas, escuchar su progreso, o navegar manualmente entre pasos durante pruebas y depuración. La mayoría de los componentes de escena y pantallas de UI terminan consultando o suscribiéndose a FluxManager.Instance.

Propiedades

Propiedad	Tipo	Descripción
`Timer`	`CountDownTimer`	El temporizador asociado al paso actualmente activo.
`CurrentStateMode`	`FluxState.FluxStateMode`	`Sequential` o `Free`, según el `FluxState` activo.
`Log`	`List<LogAction>`	Historial de acciones ejecutadas durante la secuencia actual. `LogAction` es un struct anidado con `List<Action> actions`, `int score` y `string step`.
`CountCharacterTrigger`	`const int` (`18`)	Largo fijo de un UID de trigger dentro de un string de triggers concatenados; se usa para separar múltiples triggers de un mismo string.
`SequencesList`	`List<Sequence>`	Secuencias actualmente cargadas en memoria.
`SequenceRunning`	`bool` (solo lectura)	Indica si hay una secuencia corriendo en este momento.
`CurrentSequence`	`Sequence`	La secuencia activa.
`CurrentStep`	`Step`	El paso activo de la secuencia actual.
`NextStep`	`Step`	El paso que sigue al activo.
`Config`	`FluxConfig` (solo lectura)	La configuración asociada al `FluxState` activo.
`Stage`	`string` (solo lectura)	La etapa (stage) actual dentro de la secuencia.
`AllowLoadNewSequence`	`bool`	Controla si se permite cargar una nueva secuencia mientras el manager está activo. Por defecto `false`.

Métodos

void ActiveManualStep(int index)

Activa manualmente el paso indicado por index, sin pasar por el flujo normal de evaluación de triggers. Útil para depuración o para navegación libre entre pasos durante pruebas.

void InitializeSequence()

Limpia el Log de la secuencia actual y reinicia el índice de paso activo a 0. Dispara el evento OnInitializedSequence.

virtual void StartSequence()

Comienza a ejecutar CurrentSequence desde el estado en que se encuentre (normalmente tras InitializeSequence()). Dispara el evento OnStartedSequence. Al ser virtual, puede sobrescribirse en una clase derivada para personalizar el arranque.

void FinishSequence()

Detiene el Timer del paso activo y da por terminada la secuencia en ejecución. Dispara el evento OnFinishedSequence.

void GetSequences()

Solicita la lista de secuencias disponibles a FirebaseData.Instance.GetSequences(...) y llena SequencesList con la respuesta. Al completarse, dispara el evento OnGetsSequences.

void LoadSequence(string uidSequence, string stage = "")

Carga los pasos de la secuencia identificada por uidSequence desde Firebase (opcionalmente filtrando/anotando por stage), y la agrega o mergea dentro de SequencesList si ya existía una entrada parcial. Dispara el evento OnLoadedSequence una vez completada la carga.

void LoadSequenceLocal(string uidSequence)

Carga una secuencia desde un archivo JSON local ubicado en Resources/Sequences/<uid>.json, sin depender del backend. Pensado para modo offline o pruebas locales sin conexión a Firebase.

Sequence GetSequence(string uidSequence, out int index)

Busca dentro de SequencesList la secuencia cuyo UID coincide con uidSequence. Retorna la Sequence encontrada (o su valor por defecto si no existe) y entrega por out el índice dentro de la lista.

Step GetStepCurrentSequenceByIndex(int index)

Retorna el Step ubicado en la posición index de CurrentSequence.

FluxState GetFluxStateActive()

Retorna el FluxState actualmente activo, es decir, la estrategia de comportamiento que el FluxManager está delegando en ese momento.

void AddFluxState(FluxState fluxState)

Agrega un FluxState a la lista de estados disponibles. Nota: en el código fuente este método está marcado como // TODO funcionalidad futura; actualmente la mayoría de los proyectos configuran sus FluxState de forma estática en la escena en lugar de agregarlos dinámicamente en tiempo de ejecución.

void SetState(string uidFluxState)

Cambia el FluxState activo al identificado por uidFluxState. Internamente llama OnExit() sobre el estado anterior y OnEnter() sobre el nuevo. Dispara el evento OnFluxStateChanged.

int GetIndexStepActive()

Retorna el índice del paso actualmente activo dentro de CurrentSequence.

void SetIndexStepActive(int index)

Fija directamente el índice del paso activo. Usado internamente por los distintos FluxState (por ejemplo, FreeMode_FluxState lo usa para reubicar el paso activo según el trigger disparado) y disponible para navegación manual.

int GetPreviousIndexStepActive()

Retorna el índice del paso que estaba activo antes del paso actual.

static List<string> SplitTriggers(string concatenatedTriggers)

Divide un string de triggers concatenados en una lista de UIDs individuales, usando CountCharacterTrigger (18 caracteres) como largo fijo por cada trigger. Es un método estático de utilidad, útil quien necesite descomponer un campo de triggers combinados sin pasar por una instancia de FluxManager.

Manejo de foco de la aplicación

Cuando Config.IsActiveApplicationFocus está activo, FluxManager reacciona a la pérdida y recuperación de foco de la aplicación (por ejemplo, al minimizar o cambiar de app en el dispositivo). Al perder el foco, calcula cuánto tiempo transcurrió y cuántos pasos se hubiesen "consumido" mientras la app estuvo en segundo plano (GetCountStepOnResume), respetando siempre MinRemainingTimeAfterFocus para no descontar más tiempo del que la configuración permite al paso activo. Esto evita que un usuario pierda progreso injustamente por salir brevemente de la aplicación, o que abuse del cambio de foco para "congelar" el temporizador indefinidamente.

Eventos

Todos los siguientes son eventos estáticos de FluxManager.

Evento	Delegate	Se dispara cuando...
`OnGetsSequences`	`delegate void OnGetsSequenceEvent()`	Se completó `GetSequences()`.
`OnLoadedSequence`	`delegate void OnLoadedSequenceEvent(bool isLoaded)`	Se completó `LoadSequence` o `LoadSequenceLocal`.
`OnStartedSequence`	`delegate void OnStartedSequenceEvent()`	Se llamó `StartSequence()`.
`OnInitializedSequence`	`delegate void OnInitializedSequenceEvent()`	Se llamó `InitializeSequence()`.
`OnFinishedSequence`	`delegate void OnFinishedSequenceEvent()`	Se llamó `FinishSequence()`.
`OnActivateStep`	`delegate void OnActivateStepEvent(string uidStep)`	Se activa un nuevo paso.
`OnDeactivatePreviousStep`	`delegate void OnDeactivatePreviousStepEvent(string uidStep)`	Se desactiva el paso anterior.
`OnTriggerActionSequence`	`delegate void OnTriggerActionSequenceEvent(bool isCorrect, int index)`	Se evalúa un trigger de acción disparado por el usuario.
`OnTimerFinished`	`delegate void OnTimerFinishedEvent(int index)`	El temporizador de un paso llega a cero.
`OnFluxStateChanged`	`delegate void OnFluxStateChangedEvent()`	Cambia el `FluxState` activo (llamada a `SetState`).

Ejemplo de código

using UnityEngine;
using Imova.Flux;

public class SequenceDebugLogger : MonoBehaviour
{
    private void OnEnable()
    {
        FluxManager.OnActivateStep += HandleActivateStep;
        FluxManager.OnTriggerActionSequence += HandleTriggerActionSequence;
    }

    private void OnDisable()
    {
        FluxManager.OnActivateStep -= HandleActivateStep;
        FluxManager.OnTriggerActionSequence -= HandleTriggerActionSequence;
    }

    private void HandleActivateStep(string uidStep)
    {
        Debug.Log($"[Flux] Paso activado: {uidStep}");
    }

    private void HandleTriggerActionSequence(bool isCorrect, int index)
    {
        Debug.Log($"[Flux] Trigger evaluado en índice {index}: {(isCorrect ? "correcto" : "incorrecto")}");
    }

    public void IniciarSecuencia(string uidSequence)
    {
        FluxManager.OnGetsSequences += () =>
        {
            FluxManager.OnLoadedSequence += isLoaded =>
            {
                if (isLoaded)
                {
                    FluxManager.Instance.StartSequence();
                }
            };

            FluxManager.Instance.LoadSequence(uidSequence);
        };

        FluxManager.Instance.GetSequences();
    }
}

Resumen​

Cuándo usarla​

Propiedades​

Métodos​

Manejo de foco de la aplicación​

Eventos​

Ejemplo de código​

Ver también​