OFERTA Oferta = Stock + prod.Jugador Stock = prod....

A continuación verás un ejemplo de cómo podrías estructurar tres scripts (Demanda, Oferta y Precios) para calcular el precio de mercado de cada recurso cada cierto intervalo de tiempo (ciclo). La idea principal es:

1. Demanda: Calcula la demanda total de cada materia prima tomando en cuenta población, eventos aleatorios, temporadas, etc.
2. Oferta: Calcula la oferta total (Stock total) de cada recurso, contemplando la producción del jugador y la de NPCs (o productores externos).
3. Precios: Con la demanda y la oferta, se aplica la fórmula para determinar el precio final.

El flujo podría ser:

• Cada 30 segundos (o lo que dure tu ciclo), invocas un método (o corrutina) en un PriceManager que llama a los métodos de los scripts de Demanda, Oferta y finalmente calcula el precio con el script de Precios.
• Asumes que el script Recursos (que ya tienes) contiene la información de la producción del jugador para cada materia prima.

---

Script 1: Demanda (DemandManager)

csharp
using UnityEngine;
using System.Collections;

public class DemandManager : MonoBehaviour
{
    // Parámetros base (puedes ajustarlos según tu juego)
    [Header("Población")]
    public float poblacionBase = 1000f;    // Población inicial
    public float poblacionActual;         // Población que irá variando

    [Header("Valores de Demanda por Recurso")]
    // Suponiendo que tienes varios recursos, puedes usar un array o lista
    public float[] demandaRecursos;       // Cada índice corresponde a un recurso distinto

    [Header("Parámetros de Ajuste")]
    public float variacionPoblacionMax = 50f;   // Delta aleatorio para la población
    public float variacionDemandaMax = 10f;     // Delta aleatorio para la demanda de cada recurso

    [Header("Factores Estacionales (Ejemplo)")]
    public float factorInvierno = -5f;
    public float factorVerano = 10f;
    // Puedes agregar otras estaciones o eventos

    private void Start()
    {
        // Inicializamos la población y la demanda
        poblacionActual = poblacionBase;
        demandaRecursos = new float[] { 100f, 120f, 80f }; 
        // ... o configura la longitud/valores que necesites según tus recursos
    }

    public void CalcularDemanda()
    {
        // 1) Calcular población actual (poblacionAnterior +- Δ2)
        float deltaPoblacion = Random.Range(-variacionPoblacionMax, variacionPoblacionMax);
        // Ejemplo básico: puedes sumar también eventos o factores estacionales
        poblacionActual += deltaPoblacion;
        // Evita que baje de cero
        if (poblacionActual < 0) poblacionActual = 0; 

        // 2) Calcular demanda para cada recurso
        for (int i = 0; i < demandaRecursos.Length; i++)
        {
            float deltaDemanda = Random.Range(-variacionDemandaMax, variacionDemandaMax);

            // Ajuste base por población
            // Asumimos que la demanda crece con la población
            float factorPoblacion = (poblacionActual / poblacionBase);

            // Factores estacionales (opcional)
            float factorEstacional = 0f;
            // Aquí podrías poner lógica: si es invierno, factorEstacional = factorInvierno, etc.
            // Por simplicidad, tomamos un ejemplo fijo:
            factorEstacional = factorInvierno; // si estamos en invierno, por ejemplo

            // Demanda nueva
            demandaRecursos[i] = demandaRecursos[i] * factorPoblacion 
                                 + deltaDemanda 
                                 + factorEstacional;

            // Evita valores negativos
            if (demandaRecursos[i] < 0) demandaRecursos[i] = 0;
        }
    }
}

Resumen del script

• poblacionActual se modifica cada ciclo para simular el crecimiento/disminución de la población.
• demandaRecursos se modifica en base a la población y factores estacionales/aleatorios.
• Este método CalcularDemanda() se invocará desde un manager o corrutina cada vez que quieras actualizar la demanda (cada 30 s, por ejemplo).

---

Script 2: Oferta (SupplyManager)

csharp
using UnityEngine;

public class SupplyManager : MonoBehaviour
{
    [Header("Producción Jugador (Referencia a otro Script)")]
    public Recursos recursosJugador;  // Asumiendo que "Recursos" es tu script con la producción del jugador

    [Header("Producción NPCs / Externos")]
    public float[] produccionNPCs;  // Producción total de NPCs para cada recurso

    [Header("Stock / Oferta Total")]
    public float[] ofertaRecursos;

    [Header("Parámetros de Variación de NPCs")]
    public float variacionNPCMax = 5f; // Delta aleatorio (+/-)

    private void Start()
    {
        // Inicializa en base a la cantidad de recursos que tengas
        // Deben coincidir los tamaños de ofertaRecursos, produccionNPCs y los arrays del script Recursos
        ofertaRecursos = new float[] { 0f, 0f, 0f };
        produccionNPCs = new float[] { 50f, 40f, 30f };
    }

    public void CalcularOferta()
    {
        // 1) Actualiza la producción de NPCs con alguna variación
        for (int i = 0; i < produccionNPCs.Length; i++)
        {
            float delta = Random.Range(-variacionNPCMax, variacionNPCMax);
            produccionNPCs[i] += delta;
            if (produccionNPCs[i] < 0) produccionNPCs[i] = 0; // Evitar negativos
        }

        // 2) Sumar la producción del jugador + la de NPCs para obtener la oferta
        for (int i = 0; i < ofertaRecursos.Length; i++)
        {
            // recursosJugador.cantidadProducida[i] es la producción del jugador para el recurso i
            ofertaRecursos[i] = produccionNPCs[i] + recursosJugador.cantidadProducida[i];
        }
    }
}

Resumen del script

• Se obtienen valores de producción del jugador desde el script Recursos (que ya tienes).
• Se añade la producción de NPCs, la cual sufre una variación aleatoria.
• ofertaRecursos es el array final con la oferta total de cada recurso.
• Este método CalcularOferta() se llamará también cada ciclo (cada 30 s).

---

Script 3: Precios (PriceManager)

Aquí calculamos el precio final de cada recurso usando la fórmula:

$$\text{precioMercado} = \text{precioBase} \times \left(1 + \alpha \times (\text{Demanda} - \text{Oferta})\right)$$

csharp
using UnityEngine;

public class PriceManager : MonoBehaviour
{
    [Header("Referencias a otros Scripts")]
    public DemandManager demandManager;
    public SupplyManager supplyManager;

    [Header("Parámetros de Precios")]
    public float alpha = 0.1f; // Factor de ajuste (α = 0.1)
    public float[] precioBase; // Precio base de cada recurso

    [Header("Precio Resultante")]
    public float[] precioMercado; // Precio que se recalcula cada ciclo

    private void Start()
    {
        // Asegúrate de que coincida con la cantidad de recursos
        precioBase = new float[] { 5f, 8f, 3f };
        precioMercado = new float[precioBase.Length];
    }

    public void CalcularPrecios()
    {
        for (int i = 0; i < precioBase.Length; i++)
        {
            float demanda = demandManager.demandaRecursos[i];
            float oferta = supplyManager.ofertaRecursos[i];

            float factor = 1f + alpha * (demanda - oferta);
            // Evitar que el factor baje de 0, para no tener precios negativos
            if (factor < 0) factor = 0;

            // precioMercado = precioBase * factor
            precioMercado[i] = precioBase[i] * factor;
        }
    }
}

Resumen del script

• precioBase es un array que define el costo base de cada recurso.
• Se toma la demanda del DemandManager y la oferta del SupplyManager.
• Se calcula el factor (1 + α * (Demanda - Oferta)).
• Se actualiza precioMercado[i] para cada recurso.

---

Integración (Invocar cada 30 segundos)

Para hacer que estos cálculos se realicen cada 30 segundos, podrías tener un GameManager o un script central que controle los ciclos. Por ejemplo:

csharp
using UnityEngine;
using System.Collections;

public class GameManager : MonoBehaviour
{
    public DemandManager demandManager;
    public SupplyManager supplyManager;
    public PriceManager priceManager;

    [Header("Duración de cada ciclo en segundos")]
    public float duracionCiclo = 30f;

    private void Start()
    {
        // Inicia la corrutina de ciclos
        StartCoroutine(CicloEconomico());
    }

    private IEnumerator CicloEconomico()
    {
        while (true)
        {
            // Esperamos el tiempo designado
            yield return new WaitForSeconds(duracionCiclo);

            // 1) Calcular demanda
            demandManager.CalcularDemanda();

            // 2) Calcular oferta
            supplyManager.CalcularOferta();

            // 3) Calcular precios
            priceManager.CalcularPrecios();

            // Aquí podrías notificar a otros sistemas que usen los precios
            // Por ejemplo, actualizar una UI, etc.
        }
    }
}

Flujo general

1. Start() en GameManager inicia la corrutina CicloEconomico().
2. Cada duracionCiclo segundos (por defecto 30), se llama:
   • demandManager.CalcularDemanda();
   • supplyManager.CalcularOferta();
   • priceManager.CalcularPrecios();
3. El resultado de los precios queda almacenado en priceManager.precioMercado.

---

Detalles Adicionales

• Recursos (Producción del Jugador): Asegúrate de que tu script Recursos tenga algo como:

  csharp
  public class Recursos : MonoBehaviour
  {
      public float[] cantidadProducida; // Producción actual para cada recurso
  
      // Aquí tendrías lógica para producir recursos con el tiempo,
      // o métodos que incrementen la producción según mejoras en el Tycoon, etc.
  }

  Luego, en SupplyManager, asignas esta referencia en el Inspector para que SupplyManager pueda leer recursosJugador.cantidadProducida[i].

• Control de Límites: En todos los cálculos (población, demanda, oferta, precios), conviene asegurarse de no generar números negativos o imposibles.

• Escalabilidad: Si tienes muchos recursos, podrías usar un ScriptableObject para configurarlos o incluso una base de datos.

• Eventos / Temporadas: Puedes ampliar la lógica de demanda u oferta para que factores estacionales o eventos (festividades, crisis, etc.) sumen o resten una cantidad específica y no solo sea aleatorio.

Con esta estructura modular:

• El DemandManager se encarga de todo lo relacionado con la demanda.
• El SupplyManager maneja la oferta.
• El PriceManager aplica la fórmula final.
• Un GameManager (o script de control) se encarga de orquestar la actualización de estos valores cada ciclo.

De esta manera tienes el sistema de economía funcionando de forma ordenada y fácil de mantener. ¡Ya solo quedaría ajustarlo a la lógica específica de tu juego Tycoon!

A continuación verás una versión ajustada de los tres scripts (Demanda, Oferta, Precios) teniendo en cuenta:

1. Tu script de recursos (donde almacenas mP1…mP9, etc.).
2. Tu script de ciclos, que dispara el evento onCicloCompleto cada vez que termina un ciclo productivo.
3. El deseo de no usar una corrutina adicional para estos scripts, sino suscribirse al evento en un GameManager (o script central) que reciba la notificación de onCicloCompleto.

La idea es:

• DemandManager: Calcula la demanda total de 9 materias primas (puedes ampliar si quieres incluir bienes manufacturados).
• SupplyManager: Calcula la oferta total sumando la producción del jugador (tomada desde tu script recursos) y la producción de NPC (o productores externos).
• PriceManager: Calcula el precio según la fórmula $\text{precioMercado} = \text{precioBase} \times [1 + \alpha \times (\text{Demanda} - \text{Oferta})]$.

Finalmente, un GameManager central se suscribirá al evento onCicloCompleto del script ciclos y, en cada ciclo, invocará los métodos de demanda, oferta y precios.

---

1) Script DemandManager

csharp
using UnityEngine;

public class DemandManager : MonoBehaviour
{
    [Header("Parámetros Población")]
    public float poblacionBase = 1000f;   
    public float poblacionActual = 1000f; 

    [Header("Demanda por cada MP (9 Materias Primas)")]
    public float[] demandaRecursos = new float[9];

    [Header("Rangos de variación")]
    public float variacionPoblacionMax = 50f;   
    public float variacionDemandaMax = 10f;

    [Header("Factores Estacionales (Ejemplo)")]
    public float factorInvierno = -5f;
    public float factorVerano   = 10f;
    
    // Ajusta esto si deseas más control sobre la temporada actual.
    // Por ejemplo, podrías crear un enum Temporada { Invierno, Verano, Otoño, Primavera }
    // y asignar un factor distinto según la estación.
    // Aquí lo dejaremos fijo como ejemplo.
    public bool esInvierno = true;

    private void Start()
    {
        // Valores iniciales de demanda (puedes cambiarlos según tu diseño)
        for (int i = 0; i < demandaRecursos.Length; i++)
        {
            demandaRecursos[i] = 50f + (i * 5f); 
        }
    }

    /// <summary>
    /// Llamar en cada ciclo para recalcular la demanda.
    /// </summary>
    public void CalcularDemanda()
    {
        // 1) Ajustar población
        float deltaPoblacion = Random.Range(-variacionPoblacionMax, variacionPoblacionMax);
        poblacionActual += deltaPoblacion;
        if (poblacionActual < 0) poblacionActual = 0;

        // 2) Calcular demanda base para cada recurso
        float factorPoblacion = (poblacionActual / poblacionBase);

        // Ejemplo de factor estacional
        float factorEstacional = esInvierno ? factorInvierno : factorVerano;  

        for (int i = 0; i < demandaRecursos.Length; i++)
        {
            float deltaDemanda = Random.Range(-variacionDemandaMax, variacionDemandaMax);

            // Nueva demanda = (demanda base anterior * factor población) + variación aleatoria + estacional
            float nuevaDemanda = demandaRecursos[i] * factorPoblacion + deltaDemanda + factorEstacional;

            // Evitar que caiga por debajo de 0
            if (nuevaDemanda < 0) nuevaDemanda = 0;

            demandaRecursos[i] = nuevaDemanda;
        }

        // Debug opcional
        Debug.Log("Demanda recalculada. Ej: Demanda MP1 = " + demandaRecursos[0]);
    }
}

Puntos clave

• Se asume que la demanda de 9 materias primas se almacena en el arreglo demandaRecursos.
• Cada ciclo, llamas a CalcularDemanda().
• Ajustas las fórmulas (población, estacionalidad, etc.) a tu gusto.

---

2) Script SupplyManager

csharp
using UnityEngine;

public class SupplyManager : MonoBehaviour
{
    [Header("Referencia al script 'recursos' (Producción del Jugador)")]
    public recursos recursosJugador;  // Asigna en el Inspector

    [Header("Producción NPC (o externos) para 9 MP")]
    public float[] produccionNPCs = new float[9];

    [Header("Oferta final (se recalcula cada ciclo)")]
    public float[] ofertaRecursos = new float[9];

    [Header("Variación máxima NPC por ciclo")]
    public float variacionNPCMax = 5f;

    private void Start()
    {
        // Inicializamos con algún valor base
        for(int i = 0; i < produccionNPCs.Length; i++)
        {
            produccionNPCs[i] = 50f + (i * 5f);
        }
    }

    /// <summary>
    /// Llamar en cada ciclo para recalcular la oferta total.
    /// </summary>
    public void CalcularOferta()
    {
        // 1) Variación aleatoria en producción NPC
        for (int i = 0; i < produccionNPCs.Length; i++)
        {
            float delta = Random.Range(-variacionNPCMax, variacionNPCMax);
            produccionNPCs[i] += delta;
            if (produccionNPCs[i] < 0) produccionNPCs[i] = 0;
        }

        // 2) Sumamos la producción del jugador
        // Tu script 'recursos' tiene mP1... mP9 como ENTEROS.
        // Asumamos que la "oferta" del jugador es simplemente la cantidad actual de cada mP que posee.
        // En un juego Tycoon más complejo podrías querer: 
        //   "oferta del jugador = lo que produce por ciclo" 
        //   en vez de la cantidad total que tiene almacenada.
        // Pero aquí lo tomaremos como "lo que posee" = su oferta disponible.
        // OJO: Ajusta esta lógica si necesitas un sistema distinto.

        // Construimos un array con las 9 MPs del jugador
        int[] mpJugador = new int[]
        {
            recursosJugador.mP1,
            recursosJugador.mP2,
            recursosJugador.mP3,
            recursosJugador.mP4,
            recursosJugador.mP5,
            recursosJugador.mP6,
            recursosJugador.mP7,
            recursosJugador.mP8,
            recursosJugador.mP9
        };

        for (int i = 0; i < ofertaRecursos.Length; i++)
        {
            // Oferta total = Producción NPC + (lo que el jugador posee)
            // Convertimos int del jugador a float (por si se usa en la fórmula)
            ofertaRecursos[i] = produccionNPCs[i] + mpJugador[i];
        }

        // Debug opcional
        Debug.Log("Oferta recalculada. Ej: Oferta MP1 = " + ofertaRecursos[0]);
    }
}

Puntos clave

• Se utiliza la referencia a tu script recursos (recursosJugador).
• Usamos la cantidad que el jugador tiene (mP1..mP9) como parte de la oferta. Si en tu diseño la “oferta” del jugador debiera ser sólo lo que produce por ciclo, tendrás que modificar la lógica.
• El array ofertaRecursos contendrá la oferta total final (NPC + jugador).

---

3) Script PriceManager

csharp
using UnityEngine;

public class PriceManager : MonoBehaviour
{
    [Header("Referencias")]
    public DemandManager demandManager;
    public SupplyManager supplyManager;

    [Header("Parámetros de Precios")]
    public float alpha = 0.1f; // Factor α
    public float[] precioBase = new float[9]; // Precio base para cada una de las 9 materias primas

    [Header("Precios de Mercado (Salida)")]
    public float[] precioMercado = new float[9]; // Resultado final

    private void Start()
    {
        // Inicializamos precios base
        // Ajusta estos valores según tu diseño
        for(int i = 0; i < precioBase.Length; i++)
        {
            precioBase[i] = 5f + (i * 2f); 
        }
    }

    /// <summary>
    /// Llamar en cada ciclo después de calcular Demanda y Oferta.
    /// </summary>
    public void CalcularPrecios()
    {
        for (int i = 0; i < precioBase.Length; i++)
        {
            float demanda = demandManager.demandaRecursos[i];
            float oferta  = supplyManager.ofertaRecursos[i];

            // Factor = 1 + α * (Demanda - Oferta)
            float factor = 1f + alpha * (demanda - oferta);
            // Evitamos precios negativos
            if (factor < 0) factor = 0;

            precioMercado[i] = precioBase[i] * factor;
        }

        // Debug opcional
        Debug.Log("Precio MP1 = " + precioMercado[0]);
    }
}

Puntos clave

• Se toman los valores de demandaRecursos y ofertaRecursos.
• Se aplica la fórmula para cada índice (cada materia prima).
• precioMercado se almacena con el resultado final.

---

4) GameManager (o script central)

Debido a que no quieres usar otra corrutina, sino aprovechar el evento onCicloCompleto del script ciclos, podemos crear un GameManager (o cualquier script) que se suscriba a dicho evento.

Pasos:

1. Arrastrar tus componentes (DemandManager, SupplyManager, PriceManager, ciclos) a un objeto en la escena (por ejemplo, un GameManager vacío).
2. En el Inspector, asignar las referencias.
3. Suscribirte al evento onCicloCompleto en el Start() de tu GameManager.

Ejemplo de GameManager:

csharp
using UnityEngine;

public class GameManager : MonoBehaviour
{
    [Header("Referencias")]
    public ciclos ciclosScript;        // Asigna en el Inspector, es tu script de ciclos
    public DemandManager demandManager;
    public SupplyManager supplyManager;
    public PriceManager priceManager;

    private void Start()
    {
        // Suscribirse al evento de ciclo
        if (ciclosScript != null)
        {
            ciclosScript.onCicloCompleto += OnCicloCompletoHandler;
        }
    }

    private void OnDestroy()
    {
        // Por si este objeto se destruye, desuscribirse
        if (ciclosScript != null)
        {
            ciclosScript.onCicloCompleto -= OnCicloCompletoHandler;
        }
    }

    /// <summary>
    /// Método que se llama cada vez que el evento onCicloCompleto (de 'ciclos') se dispare.
    /// </summary>
    private void OnCicloCompletoHandler()
    {
        // 1) Calcular demanda
        demandManager.CalcularDemanda();

        // 2) Calcular oferta
        supplyManager.CalcularOferta();

        // 3) Calcular precios
        priceManager.CalcularPrecios();

        // Aquí podrías hacer otras cosas, como actualizar UI, comprobar stocks, etc.
        Debug.Log("¡Ciclo completo! Se han recalculado Demanda, Oferta y Precios.");
    }
}

Flujo

1. Tu script ciclos tiene un yield return new WaitForSeconds(cicloProductivo); y al finalizar invoca onCicloCompleto.Invoke().
2. GameManager recibe ese evento (en OnCicloCompletoHandler()), y llama en orden a CalcularDemanda(), CalcularOferta() y CalcularPrecios().
3. Al final, tienes tus precios listos en priceManager.precioMercado[i].

---

Resumen Final

• DemandManager, SupplyManager y PriceManager son scripts independientes.
• El script ciclos se mantiene como está, con su onCicloCompleto.
• Creas (o usas) un GameManager que se suscriba al evento de ciclos y haga la llamada a los métodos de cálculo en cada ciclo.
• Tu script recursos provee la cantidad de materias primas del jugador, que en este ejemplo se asume como parte de la Oferta.

Ajusta los valores iniciales, las fórmulas, la forma en que se calculan las estacionalidades y la lógica de “cuánto produce el jugador” de acuerdo con la mecánica exacta de tu Tycoon.

Con esto tienes la base del sistema de economía que se actualiza automáticamente cada vez que finaliza un ciclo.

En C# (y en muchos otros lenguajes), cuando usamos un bucle for (int i = 0; i < array.Length; i++), la variable i es simplemente un índice que va recorriendo las posiciones (o “casillas”) de ese array, empezando normalmente en cero y terminando en array.Length - 1.

• array[0] se refiere a la primera posición del array.
• array[1] se refiere a la segunda posición.
• y así sucesivamente, hasta array[array.Length - 1] que es la última posición.

Por ejemplo, si tienes un array public float[] miArray = new float[5];, tendrás 5 posiciones internas (índices 0, 1, 2, 3 y 4). Cuando haces:

csharp
for (int i = 0; i < miArray.Length; i++)
{
    // Aquí i toma valores: 0, 1, 2, 3, 4
    // y puedes acceder a miArray[i]
}

• i = 0 → miArray[0]
• i = 1 → miArray[1]
• etc.

Entonces, usar array[i] en un bucle for te permite recorrer (o “iterar”) todos los elementos del array sin tener que escribir una línea de código para cada posición.

A continuación tienes un ejemplo donde hay 3 NPCs distintos, cada uno con su propia producción de las 9 materias primas. Luego, se suma todo para obtener la oferta total (NPC1 + NPC2 + NPC3 + jugador).

csharp
using UnityEngine;

public class SupplyManager : MonoBehaviour
{
    [Header("Referencia al script 'recursos' (Producción del Jugador)")]
    public recursos recursosJugador;  // Asigna en el Inspector

    [Header("Producción de cada NPC (3 NPCs, 9 MP)")]
    public float[] produccionNPC1 = new float[9];
    public float[] produccionNPC2 = new float[9];
    public float[] produccionNPC3 = new float[9];

    [Header("Oferta final (se recalcula cada ciclo)")]
    public float[] ofertaRecursos = new float[9];

    [Header("Variación máxima NPC por ciclo")]
    public float variacionNPCMax = 5f;

    private void Start()
    {
        // Iniciamos valores base para cada NPC
        // (ajusta estos valores según la lógica de tu juego)
        for (int i = 0; i < 9; i++)
        {
            produccionNPC1[i] = 50f + (i * 5f);  // Ejemplo: NPC1
            produccionNPC2[i] = 40f + (i * 3f);  // Ejemplo: NPC2
            produccionNPC3[i] = 30f + (i * 2f);  // Ejemplo: NPC3
        }
    }

    /// <summary>
    /// Se llama cada ciclo para recalcular la oferta total.
    /// </summary>
    public void CalcularOferta()
    {
        // 1) Variación aleatoria para cada NPC
        for (int i = 0; i < 9; i++)
        {
            float delta1 = Random.Range(-variacionNPCMax, variacionNPCMax);
            produccionNPC1[i] += delta1;
            if (produccionNPC1[i] < 0) produccionNPC1[i] = 0;

            float delta2 = Random.Range(-variacionNPCMax, variacionNPCMax);
            produccionNPC2[i] += delta2;
            if (produccionNPC2[i] < 0) produccionNPC2[i] = 0;

            float delta3 = Random.Range(-variacionNPCMax, variacionNPCMax);
            produccionNPC3[i] += delta3;
            if (produccionNPC3[i] < 0) produccionNPC3[i] = 0;
        }

        // 2) Tomamos la cantidad actual del jugador (mP1..mP9) como su oferta
        int[] mpJugador = new int[]
        {
            recursosJugador.mP1,
            recursosJugador.mP2,
            recursosJugador.mP3,
            recursosJugador.mP4,
            recursosJugador.mP5,
            recursosJugador.mP6,
            recursosJugador.mP7,
            recursosJugador.mP8,
            recursosJugador.mP9
        };

        // 3) Sumar las producciones de NPC1, NPC2, NPC3 y el jugador
        for (int i = 0; i < 9; i++)
        {
            // Convertimos lo que tiene el jugador a float para sumarlo con la producción NPC
            ofertaRecursos[i] = produccionNPC1[i] + produccionNPC2[i] + produccionNPC3[i] + mpJugador[i];
        }

        // Mensaje de ejemplo
        Debug.Log("Oferta recalculada. Ej: Oferta MP1 = " + ofertaRecursos[0]);
    }
}

Qué hace el script

1. Tres arrays de producción (produccionNPC1, produccionNPC2, produccionNPC3), cada uno para las 9 materias primas.
2. En Start(), se inicializan con valores diferentes para cada NPC (puedes cambiarlo según tu juego).
3. En CalcularOferta():
   • Se aplica una variación aleatoria de ±variacionNPCMax a cada materia prima de cada NPC.
   • Se asegura que no queden valores negativos.
   • Se lee cuántas materias primas posee el jugador (desde tu script recursos).
   • Finalmente, se suman las 3 producciones NPC más la cantidad del jugador, resultando en ofertaRecursos[i].

Al final de cada ciclo, cuando llamas a este método, tu variable ofertaRecursos quedará actualizada con la oferta total de las 9 materias primas.

A continuación verás un ejemplo de cómo podrías fijar la producción base de cada NPC para cada materia prima, y luego aplicar una variación diferente para cada producción (por recurso). Finalmente, se suman las producciones de los 3 NPCs y lo que el jugador tenga disponible para llegar a la oferta total.

Ejemplo de SupplyManager

csharp
using UnityEngine;

public class SupplyManager : MonoBehaviour
{
    [Header("Referencia al script 'recursos' (Producción del Jugador)")]
    public recursos recursosJugador;  // Asigna en el Inspector

    [Header("Oferta final (se recalcula cada ciclo)")]
    public float[] ofertaRecursos = new float[9];

    // --------------------------------------------------------------------------------
    // A) PRODUCCIÓN BASE DE CADA NPC (por ciclo), para las 9 materias primas.
    //    (Ajusta los valores a la lógica de tu juego)
    // --------------------------------------------------------------------------------
    private float[] baseProdNPC1 = new float[9] { 12,  5,  1,  0, 10,  2,  3,  4,  6 };
    private float[] baseProdNPC2 = new float[9] {  8,  3,  2,  2,  5,  1,  0,  3,  4 };
    private float[] baseProdNPC3 = new float[9] { 10,  7,  1,  1,  3,  4,  2,  2,  1 };

    // --------------------------------------------------------------------------------
    // B) VARIACIÓN MÁXIMA PARA CADA MATERIA PRIMA, POR NPC
    //    Esto te permite, por ejemplo, dar una variación ±2 en MP1, ±1 en MP2...
    // --------------------------------------------------------------------------------
    private float[] varMaxNPC1 = new float[9] { 2f, 1f, 0.5f,  0f, 2f, 1f, 1f, 0.5f, 2f };
    private float[] varMaxNPC2 = new float[9] { 1f, 2f,   1f, 0.5f, 3f, 1f, 0f,   2f, 1f };
    private float[] varMaxNPC3 = new float[9] { 2f, 3f,   1f,   2f, 2f, 3f, 1f,   1f, 2f };

    // --------------------------------------------------------------------------------
    // C) PRODUCCIÓN REAL DE LOS NPC EN ESTE CICLO (se actualizará cada ciclo)
    // --------------------------------------------------------------------------------
    [Header("Producción calculada cada ciclo para cada NPC")]
    public float[] produccionNPC1 = new float[9];
    public float[] produccionNPC2 = new float[9];
    public float[] produccionNPC3 = new float[9];

    private void Start()
    {
        // Si deseas inicializar los arrays produccionNPC con algún valor inicial,
        // podrías copiar la base en Start(); aunque no es estrictamente necesario,
        // ya que en cada ciclo se recalculará.
        for (int i = 0; i < 9; i++)
        {
            produccionNPC1[i] = baseProdNPC1[i];
            produccionNPC2[i] = baseProdNPC2[i];
            produccionNPC3[i] = baseProdNPC3[i];
        }
    }

    /// <summary>
    /// Llamar en cada ciclo para recalcular la oferta total.
    /// </summary>
    public void CalcularOferta()
    {
        // 1) Calcular la producción final de cada NPC (base &plusmn; variación)
        for (int i = 0; i < 9; i++)
        {
            // NPC1
            float delta1 = Random.Range(-varMaxNPC1[i], varMaxNPC1[i]);
            produccionNPC1[i] = baseProdNPC1[i] + delta1;
            if (produccionNPC1[i] < 0) produccionNPC1[i] = 0; // Evitar negativos

            // NPC2
            float delta2 = Random.Range(-varMaxNPC2[i], varMaxNPC2[i]);
            produccionNPC2[i] = baseProdNPC2[i] + delta2;
            if (produccionNPC2[i] < 0) produccionNPC2[i] = 0;

            // NPC3
            float delta3 = Random.Range(-varMaxNPC3[i], varMaxNPC3[i]);
            produccionNPC3[i] = baseProdNPC3[i] + delta3;
            if (produccionNPC3[i] < 0) produccionNPC3[i] = 0;
        }

        // 2) Leemos la cantidad actual del jugador (mP1..mP9) como "lo que el jugador ofrece"
        int[] mpJugador = new int[]
        {
            recursosJugador.mP1,
            recursosJugador.mP2,
            recursosJugador.mP3,
            recursosJugador.mP4,
            recursosJugador.mP5,
            recursosJugador.mP6,
            recursosJugador.mP7,
            recursosJugador.mP8,
            recursosJugador.mP9
        };

        // 3) Sumamos la producción de NPC1, NPC2, NPC3 y la del jugador para obtener la oferta final
        for (int i = 0; i < 9; i++)
        {
            ofertaRecursos[i] = produccionNPC1[i] 
                              + produccionNPC2[i] 
                              + produccionNPC3[i] 
                              + mpJugador[i];
        }

        // Debug opcional
        Debug.Log("Oferta recalculada. MP1 = " + ofertaRecursos[0] + ", MP2 = " + ofertaRecursos[1]);
    }
}

Detalles Importantes

1. Producción base:

   • baseProdNPC1, baseProdNPC2, baseProdNPC3 representan cuánto produce cada NPC de cada materia prima por ciclo, sin variaciones. Son arrays de 9 elementos (uno por cada MP).

2. Variación máxima:

   • varMaxNPC1, varMaxNPC2, varMaxNPC3 almacenan la variación máxima por recurso para cada NPC.
   • Por ejemplo, si varMaxNPC1[0] = 2f, significa que para la materia prima 1 (MP1), el NPC1 puede producir entre baseProdNPC1[0] - 2 y baseProdNPC1[0] + 2.

3. Producción calculada cada ciclo:

   • produccionNPC1[i] = baseProdNPC1[i] ± Random.Range(...).
   • Esto se recalcula en cada ciclo (ej. cada 15 segundos, o lo que defina tu script ciclos).

4. Suma total (oferta):

   • Al final, ofertaRecursos[i] = produccionNPC1[i] + produccionNPC2[i] + produccionNPC3[i] + mpJugador[i].
   • mpJugador[i] es la cantidad que el jugador tiene (o produce) para la materia prima i.

5. Evitar valores negativos:

   • Se hace un if (produccionNPCx[i] < 0) produccionNPCx[i] = 0; después de añadir la variación. Así no te quedas con producciones negativas.

6. Uso en el juego:

   • En tu GameManager o donde uses el evento de tu script ciclos, llama a supplyManager.CalcularOferta() en cada ciclo (después o antes de calcular la demanda, según tu lógica).

Ejemplo de llamado en tu GameManager:

csharp
public class GameManager : MonoBehaviour
{
    public ciclos ciclosScript;         // Asigna en Inspector
    public SupplyManager supplyManager; // Asigna en Inspector
    // (También DemandManager, PriceManager, etc. si los tienes)

    private void Start()
    {
        // Suscripción al evento
        ciclosScript.onCicloCompleto += OnCicloCompletoHandler;
    }

    private void OnDestroy()
    {
        ciclosScript.onCicloCompleto -= OnCicloCompletoHandler;
    }

    private void OnCicloCompletoHandler()
    {
        // Llamamos a CalcularOferta() cada vez que finaliza un ciclo
        supplyManager.CalcularOferta();
        
        // ... y luego, por ejemplo, DemandManager.CalcularDemanda()
        // ... y PriceManager.CalcularPrecios()
        Debug.Log("Ciclo completo: Oferta recalculada.");
    }
}

De esta forma, cada vez que se complete el ciclo productivo (tu script ciclos hace onCicloCompleto.Invoke()), obtendrás una nueva oferta actualizada con la producción de cada NPC (más la del jugador).

A continuación encontrarás un ejemplo de cómo podrías estructurar tu DemandManager para que cada materia prima (MP) tenga:

1. Un porcentaje base de la población total (diferente para cada MP).
2. Variaciones debidas a eventos aleatorios, temporada, etc.
3. Fórmulas separadas para la población y para cada demanda de MP (tal como describes: $\Delta2$ para la población y $\Delta1$ para la demanda).

La lógica está inspirada en tu diagrama:

text
DEMANDA para cada MP = consumidores ± Δ1
consumidores = %poblacionTotal
poblacionTotal = poblacionAnterior ± Δ2

Δ1 = (eventos aleatorios) ± (temporada)
Δ2 = (eventos aleatorios) ± (temporada) ± Δ3
Δ3 = número aleatorio dentro de un rango

Nota: Los nombres y valores son un ejemplo. Adáptalos a tu juego, ajustando los rangos y factores según tu diseño.

---

Script: DemandManager

csharp
using UnityEngine;

public class DemandManager : MonoBehaviour
{
    [Header("=== Población ===")]
    [Tooltip("Población inicial")]
    public float poblacionActual = 1000f;

    [Tooltip("Variación aleatoria (eventos) mínima y máxima para la población")]
    public float minEventoPoblacion = -20f;
    public float maxEventoPoblacion =  20f;

    [Tooltip("Factor de temporada para la población (invierno)")]
    public float factorInviernoPoblacion = -10f;
    [Tooltip("Factor de temporada para la población (verano)")]
    public float factorVeranoPoblacion   =  30f;

    [Tooltip("Rango para delta3 (población)")]
    public float minDelta3 = -10f;
    public float maxDelta3 =  10f;

    [Header("=== Demanda por cada MP (9 Materias Primas) ===")]
    public float[] demandaRecursos = new float[9];

    [Tooltip("Porcentaje base de la población que demanda cada MP")]
    public float[] porcentajeBaseMP = new float[9]
    {
        0.12f, // MP1
        0.08f, // MP2
        0.05f, // MP3
        0.07f, // MP4
        0.10f, // MP5
        0.02f, // MP6
        0.04f, // MP7
        0.09f, // MP8
        0.03f  // MP9
    };

    [Tooltip("Variación aleatoria (eventos) mínima y máxima para cada MP")]
    public float minEventoDemanda = -5f;
    public float maxEventoDemanda =  5f;

    [Tooltip("Factor de temporada para la demanda (invierno)")]
    public float factorInviernoDemanda = -3f;
    [Tooltip("Factor de temporada para la demanda (verano)")]
    public float factorVeranoDemanda   =  5f;

    [Header("=== Temporada Actual ===")]
    public bool esInvierno = true;

    void Start()
    {
        // (Opcional) Inicializar las demandas con algún valor de arranque
        for (int i = 0; i < demandaRecursos.Length; i++)
        {
            // Por ejemplo, el consumo inicial podría ser simplemente el porcentaje base * población inicial
            demandaRecursos[i] = porcentajeBaseMP[i] * poblacionActual;
        }
    }

    /// <summary>
    /// Llamar en cada ciclo para recalcular la población y la demanda.
    /// </summary>
    public void CalcularDemanda()
    {
        // ==================================================
        // 1) Calcular la nueva población (poblacionTotal = poblacionAnterior &plusmn; Δ2)
        //    Δ2 = (eventos aleatorios) &plusmn; (temporada) &plusmn; Δ3
        // ==================================================

        float eventoPop = Random.Range(minEventoPoblacion, maxEventoPoblacion);  // "eventos aleatorios" para población
        float factorTemporadaPop = esInvierno ? factorInviernoPoblacion : factorVeranoPoblacion; // invierno/verano
        float delta3 = Random.Range(minDelta3, maxDelta3); // número extra aleatorio

        float delta2 = eventoPop + factorTemporadaPop + delta3; // Este es tu Δ2
        poblacionActual += delta2;

        // Evitar población negativa
        if (poblacionActual < 0)
            poblacionActual = 0;

        // ==================================================
        // 2) Para cada MP, calcular Demanda = consumidores &plusmn; Δ1
        //    donde consumidores = %poblacionTotal
        //    y Δ1 = (eventos aleatorios) &plusmn; (temporada)
        // ==================================================

        // Elegimos un factor de temporada para la DEMANDA
        float factorTemporadaDemanda = esInvierno ? factorInviernoDemanda : factorVeranoDemanda;

        for (int i = 0; i < demandaRecursos.Length; i++)
        {
            // Base: porcentaje de la población que demanda este MP
            float consumidores = porcentajeBaseMP[i] * poblacionActual;

            // "eventos aleatorios" específicos para la demanda de este MP
            float eventoDemandMP = Random.Range(minEventoDemanda, maxEventoDemanda);

            // Δ1 = eventoDemandMP + factorTemporadaDemanda
            float delta1 = eventoDemandMP + factorTemporadaDemanda;

            // Demanda final para esta MP
            float nuevaDemanda = consumidores + delta1;

            // Asegurar que no sea negativa
            if (nuevaDemanda < 0)
                nuevaDemanda = 0;

            demandaRecursos[i] = nuevaDemanda;
        }

        // Debug opcional
        Debug.Log(">>> DEMANDA recalculada. " +
                  "\nPoblación = " + poblacionActual +
                  "\nDemanda MP1 = " + demandaRecursos[0] +
                  "\nDemanda MP2 = " + demandaRecursos[1]);
    }
}

Explicación Paso a Paso

1. Población

   • En cada ciclo, se calcula Δ2 con la fórmula: $$\Delta2 = (\text{eventoPop}) \;+\; (\text{factorTemporadaPop}) \;+\; (\delta3)$$ donde:
     • eventoPop = un valor aleatorio en $[minEventoPoblacion, maxEventoPoblacion]$.
     • factorTemporadaPop = un valor que depende de si es invierno ($factorInviernoPoblacion$) o verano ($factorVeranoPoblacion$).
     • delta3 = otro valor aleatorio en $[minDelta3, maxDelta3]$.
   • Se suma Δ2 a poblacionActual, y se evita que baje de 0.

2. Demanda por MP

   • Para cada MP, primero obtenemos consumidores = porcentajeBaseMP[i] * poblacionActual.
     • Este porcentaje ($porcentajeBaseMP[i]$) es el tanto por uno de la población que consume esa materia prima.
     • Por ejemplo, si porcentajeBaseMP[0] = 0.12, significa que un 12% de la población consume MP1.
   • Luego calculamos Δ1 = (evento aleatorio para la demanda) + (factor de temporada para la demanda).
     • eventoDemandMP = un valor aleatorio en $[minEventoDemanda, maxEventoDemanda]$.
     • factorTemporadaDemanda depende de invierno/verano.
   • Finalmente, Demanda = consumidores + Δ1.

3. Evitar negativos

   • Tanto la población como la demanda de cada MP se igualan a 0 si el cálculo diera algo negativo.

4. Rangos y factores

   • minEventoPoblacion, maxEventoPoblacion, factorInviernoPoblacion, factorVeranoPoblacion, etc., son ajustables en el Inspector para que puedas afinar la magnitud de los cambios.
   • porcentajeBaseMP es un array donde cada posición define el porcentaje de población que consume una materia prima (MP1..MP9).

5. Invocación

   • Cada vez que finaliza un ciclo (por ejemplo, desde tu GameManager suscrito a onCicloCompleto), llamas a demandManager.CalcularDemanda().

---

Resumen

Este script ilustra una forma de implementar tu fórmula:

• $\poblacionTotal = \poblacionAnterior \pm \Delta2$
• \text{Demanda}_{MP} = (\text{%poblacion}) \pm \Delta1

donde se incluyen factores estacionales, eventos aleatorios y un número adicional $\Delta3$. Además, cada MP tiene un porcentaje distinto de la población que la consume, resultando en demandas iniciales diferentes para cada MP. Luego se añaden variaciones de temporada y eventos para que cada materia prima fluctúe de forma separada y un poco impredecible.

Sí, exactamente. Tal como está escrito el script:

csharp
// ...
float delta2 = eventoPop + factorTemporadaPop + delta3;
poblacionActual += delta2; 
// ...

se va acumulando la nueva población sobre la anterior. En cada ciclo, el valor de poblacionActual será:

población del ciclo anterior + (eventos + temporada + número aleatorio)

Por ejemplo:

• Ciclo 1: Comienzas con 100 de población.
• Ciclo 2: Se calcula $\Delta2$ (digamos +12). Entonces la población pasa a 100 + 12 = 112.
• Ciclo 3: Se vuelve a calcular un nuevo $\Delta2$ (imaginemos +8). La población ahora se convierte en 112 + 8 = 120.

De esta manera, cada ciclo se toma como punto de partida la población del ciclo anterior, lo cual produce ese crecimiento (o decrecimiento) inercial. Si quisieras que cada ciclo la población se recalculara partiendo de un valor fijo, tendrías que reasignar la población en lugar de sumarla (por ejemplo, poblacionActual = basePoblacion + delta2), pero con la lógica actual se “arrastra” el valor desde el ciclo previo.

El problema ocurre porque en estas líneas estás intentando hacer:

csharp
produccionNPC1MP = prodBaseNPC1MP + delta1;

y C# interpreta que prodBaseNPC1MP es un array (float[]), mientras que delta1 es un float, y no puedes sumar directamente un array y un float.

Lo que quieres realmente es actualizar la posición i del array produccionNPC1MP con la suma de la posición i de prodBaseNPC1MP más el valor de delta1.

En otras palabras, la corrección es:

csharp
produccionNPC1MP[i] = prodBaseNPC1MP[i] + delta1;
produccionNPC2MP[i] = prodBaseNPC2MP[i] + delta2;
produccionNPC3MP[i] = prodBaseNPC3MP[i] + delta3;

Versión corregida del script

csharp
using UnityEngine;

public class ofertaMercado : MonoBehaviour
{
    public recursos scriptRecursos;

    public float[] ofertaMP = new float[9];

    // producción base de los NPCs
    public float[] prodBaseNPC1MP = new float[9] { 12, 3, 1, 0, 0, 0, 0, 0, 0 };
    public float[] prodBaseNPC2MP = new float[9] { 6, 9, 2, 0, 0, 0, 0, 0, 0 };
    public float[] prodBaseNPC3MP = new float[9] { 18, 6, 3, 0, 0, 0, 0, 0, 0 };

    // variación en la producción (máximos +/-)
    public float[] varProdNPC1MP = new float[9] { 12, 3, 1, 0, 0, 0, 0, 0, 0 };
    public float[] varProdNPC2MP = new float[9] { 6, 9, 2, 0, 0, 0, 0, 0, 0 };
    public float[] varProdNPC3MP = new float[9] { 18, 6, 3, 0, 0, 0, 0, 0, 0 };

    // producción total de los NPCs (resultado en cada ciclo)
    public float[] produccionNPC1MP = new float[9];
    public float[] produccionNPC2MP = new float[9];
    public float[] produccionNPC3MP = new float[9];

    public void CalcularOferta()
    {
        for (int i = 0; i < 9; i++)
        {
            float delta1 = Random.Range(-varProdNPC1MP[i], varProdNPC1MP[i]);
            // Asigna valor a produccionNPC1MP[i], no al array completo
            produccionNPC1MP[i] = prodBaseNPC1MP[i] + delta1;
            if (produccionNPC1MP[i] < 0) produccionNPC1MP[i] = 0;

            float delta2 = Random.Range(-varProdNPC2MP[i], varProdNPC2MP[i]);
            produccionNPC2MP[i] = prodBaseNPC2MP[i] + delta2;
            if (produccionNPC2MP[i] < 0) produccionNPC2MP[i] = 0;

            float delta3 = Random.Range(-varProdNPC3MP[i], varProdNPC3MP[i]);
            produccionNPC3MP[i] = prodBaseNPC3MP[i] + delta3;
            if (produccionNPC3MP[i] < 0) produccionNPC3MP[i] = 0;
        }

        // Conversión a int[] de las materias primas del jugador
        int[] prodJugadorMP = new int[]
        {
            scriptRecursos.mP1,
            scriptRecursos.mP2,
            scriptRecursos.mP3,
            scriptRecursos.mP4,
            scriptRecursos.mP5,
            scriptRecursos.mP6,
            scriptRecursos.mP7,
            scriptRecursos.mP8,
            scriptRecursos.mP9
        };

        // Sumamos las producciones totales de NPC1, NPC2, NPC3 y el jugador
        for (int i = 0; i < 9; i++)
        {
            ofertaMP[i] = produccionNPC1MP[i] 
                        + produccionNPC2MP[i] 
                        + produccionNPC3MP[i] 
                        + prodJugadorMP[i];
        }

        Debug.Log(">>>OFERTA RECALCULADA. " +
            "\nGrano = " + ofertaMP[0] +
            "\nHortalizas = " + ofertaMP[1] +
            "\nFruta = " + ofertaMP[2]);
    }
}

Con esto, se soluciona el error CS0019 ("Operator '+' cannot be applied to operands of type 'float[]' and 'float'"), puesto que ahora estamos sumando valores elemento a elemento en el array en lugar de intentar sumar un array completo con un valor flotante.