How to change scale of spawning prefabs depending on score?

UPDATE

Allow me to organize this question in another way. Forgive me, my previous code may have been confusing and I have made a few changes.

As the player collides with the objects being spawned, the objects being spawned are destroyed and the player gains a point. When the player earns a certain amount of points (in this case lets say 3) the objects being spawned will begin to get smaller.

The Main Goal

The player gains 3 points, the objects being spawned scale down by a small fraction (in this case 0.1). Repeat this process every time the player gets 3 points.

Current Logic

-Game Manager-

First let me show you what is keeping track of the score inside the Game Manager.

//Singleton
public static GameManager gameManager { get; private set; }

//if repeat score = 4 reset to 0 to repeat the process  
public int repeatScoreGoal = 4;

[HideInInspector]
public int repeatScore = 0;

//access this method in another script to increase repeatScore value
//when they player collides and destroys object
public void RepeatScore()
{
    repeatScore += 1;

    if (repeatScore >= repeatScoreGoal)
    {
        repeatScore = 0;
    }
}

-Collision Detection to Increase Score-

Here is the method on the script attached to the player to increase score when the player collides with the object.

  private const string tagDestructible = "Destructible";

  private void OnCollisionEnter(Collision other)
{

    if (other.gameObject.tag == tagDestructible)
    {
        if(other.gameObject.tag == tagDestructible)
        {
            GameManager.gameManager.RepeatScore();
        }
        
        Destroy(other.gameObject);
    }

-Prefab Scale Script Attached to Prefab-

This time instead of scaling the object in the "ObjectSpawner" script, I created a simple script to attach to the prefab itself so each prefab can have its own unique scale. This allows me to not have to recreate the empty game object that the "ObjectSpawner" script is attached to when I want to spawn different objects. The scale would change to a unique value for each prefab which will come in handy later down the road.

using UnityEngine;

public class PrefabScale : MonoBehaviour
{
    
    public int recScore = 3;
    private int currentScore;

    private bool objectScale = false;

void Update()
{
    //variable referencing to singleton
    currentScore = GameManager.gameManager.repeatScore;
    
    //if reapeatSore in Game Manager = recScore, scale object
    if (currentScore >= recScore && objectScale == false)
    {
        objectScale = true;

        if (objectScale == true)
        {
            gameObject.transform.localScale += new Vector3(-0.1f, -0.1f, 
            -0.1f);
        }

        if (currentScore == 0)
        {
            objectScale = false;
        }
    }
}

-Object Spawner Script Attached to Empty Game Object Spawning Prefabs-

Now lets see the "ObjectSpawner" script that is attached to an empty game object spawning the prefabs.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjectSpawn : MonoBehaviour
{
    [SerializeField]
    float[] percentages;

    public GameObject[] prefab;

    public float spawnRate = 1f;
    public float minHeight = -1f;
    public float maxHeight = 1f;

    public int recScore = 3;
    private int currentScore;
    
    //ignore these variables, view notes in update method for more info
    /*
    private bool spawnPointPosition = false;
    private float resetSpawnPoint;
    */

private void OnEnable()
{
    InvokeRepeating(nameof(Spawn), spawnRate, spawnRate);
}

private void OnDisable()
{
    CancelInvoke(nameof(Spawn));
}

private void Spawn()
{
    GameObject objects = Instantiate(prefab[GetRandomSpawn()], 
    transform.position,
    Quaternion.identity);
    objects.transform.position += Vector3.up * Random.Range(minHeight, 
    maxHeight);
    objects.transform.SetParent(transform);
}

private int GetRandomSpawn()
{
    float random = Random.Range(0f, 1f);
    float numForAdding = 0;
    float total = 0;
    for (int i = 0; i < percentages.Length; i++)
    {
        total += percentages[i];
    }

    for (int i = 0; i < prefab.Length; i++)
    {
        if (percentages[i] / total + numForAdding >= random)
        {
            return i;
        }
        else
        {
            numForAdding += percentages[i] / total;
        }
    }
    return 0;
}

private void Update()
{
    /*I left this singleton reference here just incase we need it for 
      the current problem we are trying to sovle */
    currentScore = GameManager.gameManager.repeatScore;
    
    

    /*ignore this below, this is adjusting the x position of the 
      empty game object that is spawning the prefabs and does not relate 
      to the scaling of the prefabs*/
    /*

    resetSpawnPoint = GameManager.gameManager.score;

    if (currentScore >= recScore && spawnPointPosition == false)
    {
        spawnPointPosition = true;

        if (spawnPointPosition == true)
        {
            gameObject.transform.position += new Vector3(0f, 0f, 0f);
        }

    }

    if (currentScore == 0)
    {
        spawnPointPosition = false;
    }

    if (resetSpawnPoint == 0)
    {
        gameObject.transform.position = new Vector3(20f, 0f, 0f);
    }
    */
}

}

Current Results

With this current setup, When the player earns the required score (in this case we are still just going to say 3) the objects that are currently spawned will scale.

However, the objects that spawn after that scale are the original size of the prefab until the player hits the required score again. I'm looking for a way to retain that scale with the newly spawned objects and for this entire process to repeat every time the player gets 3 points.

What is currently happening:

The game starts, the objects scale is 1. The player destroys 3 objects earning 3 points. All objects on the screen scale to 0.9. All objects being spawned after are back to scale 1.

I am looking for:

The game starts, the player gets 3 points, objects on screen scale to 0.9. Newly spawned objects are also scale 0.9. the player gets another 3 points. objects on screen are now scale to 0.8. Newly spawned objects are also scaled to 0.8. The process just keeps going.

I hope this clears some things up! Thank you all so much for your time and input!

This should be possible:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ObjectSpawn : MonoBehaviour
{
[SerializeField]
float[] percentages;
public GameObject[] prefab;
public float spawnRate = 1f;
public float minHeight = -1f;
public float maxHeight = 1f;
public int recScore = 3;
private int currentScore;
private List<GameObject> spawnedObjects = new List<GameObject>(); // Store references to the spawned objects
private List<GameObject> newSpawnedObjects = new List<GameObject>(); // Store references to newly spawned objects
private bool isScaling = false; // Flag to track if scaling is in progress
private bool isNewSpawnScaled = false; // Flag to track if newly spawned objects have been scaled
private void OnEnable()
{
InvokeRepeating(nameof(Spawn), spawnRate, spawnRate);
}
private void OnDisable()
{
CancelInvoke(nameof(Spawn));
}
private void Spawn()
{
GameObject spawnedObject = Instantiate(prefab[GetRandomSpawn()], transform.position, Quaternion.identity);
spawnedObject.transform.position += Vector3.up * Random.Range(minHeight, maxHeight);
spawnedObject.transform.SetParent(transform);
spawnedObjects.Add(spawnedObject);
newSpawnedObjects.Add(spawnedObject);
if (currentScore >= recScore && !isScaling && !isNewSpawnScaled)
{
StartCoroutine(ScaleSpawnedObjects());
}
}
private Vector3 GetScaleFactor()
{
// Define the scaling factor you want to apply
Vector3 scaleFactor = new Vector3(0.9f, 0.9f, 0.9f);
return scaleFactor;
}
private int GetRandomSpawn()
{
// ... (your existing code)
}
private IEnumerator ScaleSpawnedObjects()
{
isScaling = true;
Vector3 scaleFactor = GetScaleFactor();
foreach (GameObject spawnedObject in spawnedObjects)
{
if (spawnedObject != null)
{
spawnedObject.transform.localScale = Vector3.Scale(spawnedObject.transform.localScale, scaleFactor);
yield return null; // Wait for the next frame before scaling the next object
}
}
foreach (GameObject newSpawnedObject in newSpawnedObjects)
{
if (newSpawnedObject != null)
{
newSpawnedObject.transform.localScale = Vector3.Scale(newSpawnedObject.transform.localScale, scaleFactor);
}
}
isNewSpawnScaled = true; // Set the flag to indicate that newly spawned objects have been scaled
isScaling = false;
}
private void Update()
{
currentScore = GameManager.gameManager.repeatScore;
if (currentScore >= recScore && !isScaling && !isNewSpawnScaled)
{
StartCoroutine(ScaleSpawnedObjects());
}
if (currentScore == 0)
{
isNewSpawnScaled = false; // Reset the flag when the score reaches 0
newSpawnedObjects.Clear(); // Clear the list of newly spawned objects
}
}
}

UPDATE: When the currentScore is greater than or equal to the recScore, the ScaleSpawnedObjects method is called to scale the existing objects.
When the currentScore is less than the recScore, the ResetScale method is called to reset the scale of the objects to the initial scale.

Updated after comments from OP

Edited the script to use a Getter/Setter for the currentScore to simplify how the scale is updated and applied to new and active objects

// Target score before the scale is changed
private int targetScore = 3;
// var to hold the currentScore for use in the getter/setter
private int currentScore = 0;
// Getter/Setter for the currentScore that will update the objects scale if the currentScore reaches the targetScore before resetting the currentScore
private int CurrentScore
{
get { return currentScore; }
set
{
currentScore = value;
if (currentScore == targetScore)
{
scale -= 0.1f * Vector3.one;
for (int x = 0; x < objects.Count; x++)
{
objects[x].transform.localScale = scale;
}
currentScore = 0;
}
}
}
// Var for the current scale that will be modified in the Getter/Setter and can be used when spawning a new object
private Vector3 scale = Vector3.one;
// List of objects to loop through for scale changes
private List<GameObject> objects = new List<GameObject>();
// Simplified Spawn method that sets the current scale and adds it to the list for future updates
private void Spawn()
{
GameObject newObject = Instantiate(prefab[GetRandomSpawn()], transform.position,Quaternion.identity);
newObject.transform.position += Vector3.up * Random.Range(minHeight, maxHeight);
newObject.transform.SetParent(transform);
newObject.transform.localScale = scale;
objects.Add(newObject);
}
// Usage
private void Update()
{
if (DidWhateverItIsThatScores)
{
CurrentScore++;
}
}

Getter/Setters are perfect for this for more info see Docs

Note: You will want to clamp the scale so it has a minimum scale and doesn't go negative.