Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

Quiero que en FillWith Missellaneous no se den las cartas tan al azar, quiero que se de…

  1. User

    Quiero que en FillWith Missellaneous no se den las cartas tan al azar, quiero que se de un poco más equilibrado, para evitar que se de muchas veces la misa carta

    using System; using Cards; using UnityEngine.Serialization;

    namespace Game.Systems { using System.Collections.Generic; using System.Linq; using UnityEngine;

    [System.Serializable]
    public class Pair<Card>
    {
        public Card First;
        public Card Second;
    }
    
    public class CardSelector : MonoBehaviour
    {
        [SerializeField] CardRepartitionData cardRepartitionDataScriptable;
        private CardRepartitionData cardRepartitionData;
        private System.Random random = new System.Random();
        private Dictionary<int, CardInfo> gameObjectToCardInfoMap = new Dictionary<int, CardInfo>();
        public Dictionary<int, int> timesCardPlaced = new Dictionary<int, int>();
    
        public void Init()
        {
            cardRepartitionData = CloneScriptableObject.Clone<CardRepartitionData>(cardRepartitionDataScriptable);
            AssociateCardsWithGameObjects();
            FillCardsInPlay();
        }
        
        public List<Pair<GameObject>> GenerateCardPairsForTurn(int turnIndex)
        {
            var selectedCardPairs = new List<Pair<GameObject>>();
            
            if (turnIndex >= GetTurnsCount())
            {
                Debug.LogError("Turn index out of range.");
                return selectedCardPairs;
            }
    
            UpdateMaxCardsInPlayForTurn(turnIndex);
            
            TurnRepartition turnSettings = cardRepartitionData.turns[turnIndex];
    
            // Respeta las cartas fijas
            EnsurePairListSize(selectedCardPairs, turnSettings.cardsInTurn / 2);
            
            AddFixedCardsToPairs(turnSettings, selectedCardPairs);
            
            // Selecciona cartas por colecciones específicas
            var selectedCardsByCollection = SelectCardsByCollection(selectedCardPairs, turnSettings, turnIndex);
            foreach (var cardInfo in selectedCardsByCollection)
            {
                AddCardToPair(selectedCardPairs, cardInfo.card);
            }
    
            // Rellenar pares adicionales si es necesario, según cardsInTurn
            FillWithMiscellaneous(selectedCardPairs, turnSettings, turnIndex);
    
            UnpairDuplicates(selectedCardPairs);
            
            return selectedCardPairs;
        }
    
        public int GetTurnsCount()
        {
            return cardRepartitionData.turns.Count;
        }
    
        private void AddFixedCardsToPairs(TurnRepartition turnSettings, List<Pair<GameObject>> pairsList)
        {
            foreach (var fixedCard in turnSettings.fixedCards.OrderBy(c => c.index))
            {
                // Asegurar que la lista tenga un tamaño adecuado
                Pair<GameObject> pairAtFixedIndex = pairsList[fixedCard.index];
                
                // Si First y Second ya están asignados, ignora las cartas adicionales con el mismo índice.
                if (pairAtFixedIndex.First == null)
                {
                    pairAtFixedIndex.First = fixedCard.card;
                }
                else if (pairAtFixedIndex.Second == null)
                {
                    pairAtFixedIndex.Second = fixedCard.card;
                }
            }
        }
    
        public struct CardWithAdjustedProb
        {
            public CardInfo Card;
            public float probability;
        }
        
        private CardInfo DrawWeightedRandomCard(List<CardInfo> cardList, int turnIndex)
        {
            // Necesitas crear una estructura temporal para manejar cartas con sus probabilidades ajustadas para el turno actua
            
            List<CardWithAdjustedProb> tempCardListWithAdjustedProb = new List<CardWithAdjustedProb>();
    
            foreach (var card in cardList)
            {
            
                List<InitialTurns> sortedList = card.initialTurns.OrderBy(it => it.initialTurn).ToList();
                
                foreach (var it in sortedList)
                {
                    if(it.initialTurn <= turnIndex && card.currentCardsInPlay < it.maxCardsAllowed)
                    {
                        tempCardListWithAdjustedProb.Add(new CardWithAdjustedProb
                        {
                            Card = card,
                            probability = it.probability
                        });
                        
                        break;
                    }
                }
            }
            
            
            float totalWeight = tempCardListWithAdjustedProb.Sum(c => c.probability);
    
            float randomNumber = (float)random.NextDouble() * totalWeight;
    
            float accumulatedProbability = 0;
            foreach (var item in tempCardListWithAdjustedProb)
            {
                accumulatedProbability += item.probability;
                if (randomNumber <= accumulatedProbability)
                {
                    return item.Card;
                }
            }
    
            return null; // En caso de no encontrar una carta adecuada.
        }
    
        
        private void EnsurePairListSize(List<Pair<GameObject>> list, int size)
        {
            while (list.Count < size)
            {
                list.Add(new Pair<GameObject>());
            }
        }
        
        private List<CardInfo> GetAllAvailableCardsForTurn(TurnRepartition turnSettings, int turnIndex)
        {
            // Este método debe ser completado con lógica para filtrar cartas disponibles con base en las reglas específicas,
            // como el inicio del turno de disponibilidad y el máximo de copias por turno.
            // Esto es solo un esquema.
            List<CardInfo> result = new List<CardInfo>();
            foreach (var collection in cardRepartitionData.availableCards)
            {
                foreach (var card in collection.Value)
                {
                    List<InitialTurns> initialTurns = new List<InitialTurns>();
                    
                    foreach (var turnInfo in card.initialTurns)
                    {
                        if (turnInfo.initialTurn <= turnIndex) // Carta está disponible
                        {
                            initialTurns.Add(turnInfo);
                        }
                        
                    }
    
                    if (initialTurns.Count > 0)
                    {
                        var newCardInfo = new CardInfo()
                        {
                            card = card.card, 
                            collection = card.collection,
                            maxCopiesInTurn = card.maxCopiesInTurn, 
                            initialTurns = initialTurns, 
                            remainingCopies = card.maxCopiesInTurn,
                            maxCardsInPlay = card.maxCardsInPlay,
                            currentCardsInPlay = card.currentCardsInPlay
                        };
                        
                        result.Add(newCardInfo);
                    }
    
                }
            }
            return result;
        }
        
        private List<CardInfo> SelectCardsByCollection(List<Pair<GameObject>> selectedCardPairs,
            TurnRepartition turnSettings, int turnIndex)
        {
            List<CardInfo> selectedCards = new List<CardInfo>();
    
            foreach (var collectionEntry in turnSettings.cardsPerCollection)
            {
                var cardsAvailable = GetAllAvailableCardsForTurn(turnSettings, turnIndex);
    
                List<CardInfo> cardsInThisCollection = new List<CardInfo>();
    
                foreach (var card in cardsAvailable)
                {
                    if (card.collection == collectionEntry.Key)
                    {
                        cardsInThisCollection.Add(card);
                    }
                }
                
                List<CardInfo> sortedCards = new List<CardInfo>();
                    
                if (cardsInThisCollection.Any())
                {
                    sortedCards = cardsInThisCollection.OrderBy(card => card.initialTurns.Min(it => it.initialTurn)).ToList();
                }
                else
                {
                    continue;
                }
    
                int cardsToSelect = collectionEntry.Value;
    
                List<CardInfo> copySortedCards = new List<CardInfo>(sortedCards);
                
                foreach (var card in copySortedCards)
                {
                    if (card.currentCardsInPlay >= card.maxCardsInPlay)
                    {
                        sortedCards.Remove(card);
                    }
                    else if (card.maxCardsInPlay - card.currentCardsInPlay < card.remainingCopies)
                    {
                        card.remainingCopies = card.maxCardsInPlay - card.currentCardsInPlay;
                    }
    
                    if (CountCardPair(selectedCardPairs, card) >= card.maxCopiesInTurn)
                    {
                        sortedCards.Remove(card);
                    }
                }
    
                while (cardsToSelect > 0 && sortedCards.Any())
                {
                    CardInfo selectedCard = DrawWeightedRandomCard(sortedCards, turnIndex);
                    if (selectedCard != null)
                    {
                        selectedCards.Add(selectedCard);
                        // Decrementar remainingCopies en lugar de remover la carta de la lista
                        selectedCard.remainingCopies -= 1;
    
                        // Si no quedan copias restantes, remover la carta de futuras selecciones
                        if (selectedCard.remainingCopies <= 0)
                        {
                            sortedCards.Remove(selectedCard);
                        }
    
                        if (CountCardPair(selectedCardPairs, selectedCard) >= selectedCard.maxCopiesInTurn)
                        {
                            sortedCards.Remove(selectedCard);
                        }
                        
                        cardsToSelect--;
                    }
                }
            }
    
            return selectedCards;
        }
        
        private void AddCardToPair(List<Pair<GameObject>> pairsList, GameObject cardToAdd)
        {
            System.Random rng = new System.Random(); 
            
            var emptyFirstPairs = pairsList.Where(pair => pair.First == null).ToList();
    
            if (emptyFirstPairs.Count > 0)
            {
                // Si encontramos pares vacíos, selecciona uno al azar y asigna la carta a First.
                int randomIndex = rng.Next(emptyFirstPairs.Count);
                emptyFirstPairs[randomIndex].First = cardToAdd;
            }
            else
            {
                // Si no hay pares con First vacío, buscamos uno que sólo tenga Second vacío.
                var secondNullPairs = pairsList.Where(pair => pair.Second == null).ToList();
                if (secondNullPairs.Count > 0)
                {
                    // Selecciona aleatoriamente un par para completarlo.
                    int randomIndex = rng.Next(secondNullPairs.Count);
                    secondNullPairs[randomIndex].Second = cardToAdd;
                }
                else
                {
                    // Si todos los pares están completos, o estamos tratando de llenar más allá de los pares fijos, agregamos un nuevo par.
                    var newPair = new Pair<GameObject>() { First = cardToAdd };
                    pairsList.Add(newPair);
                }
            }
    
        }
        
        private Dictionary<CardColection, float> CalculateUrgencyScores(TurnRepartition turnSettings, Expectations currentState)
        {
            // Imaginemos que currentState refleja el estado actual del juego por cada recurso
            var urgencyScores = new Dictionary<CardColection, float>();
    
            // Calcular el déficit o superávit para cada expectativa
            urgencyScores[CardColection.Gold] = (turnSettings.expectations.gold - currentState.gold) / (float)turnSettings.expectations.gold;
            urgencyScores[CardColection.Wood] = (turnSettings.expectations.wood - currentState.wood) / (float)turnSettings.expectations.wood;
            urgencyScores[CardColection.Food] = (turnSettings.expectations.food - currentState.food) / (float)turnSettings.expectations.food;
            urgencyScores[CardColection.Stone] = (turnSettings.expectations.stone - currentState.stone) / (float)turnSettings.expectations.stone;
            urgencyScores[CardColection.Population] = (turnSettings.expectations.population - currentState.population) / (float)turnSettings.expectations.population;
            
            return urgencyScores;
        }
        
        private void FillWithMiscellaneous(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings, int turnIndex)
        {
            // Obtener todas las cartas misceláneas disponibles.
            var miscellaneousCards = GetAllAvailableCardsForTurn(turnSettings, turnIndex)
                .Where(card => card.collection == CardColection.Miscellaneous).ToList();
    
            // Asegúrate de que la lista de pares tenga el tamaño adecuado basado en cardsInTurn.
            EnsurePairListSize(pairsList, turnSettings.cardsInTurn / 2);
    
            // Llenar los pares restantes con cartas misceláneas.
            while (IsPairListFillingNeeded(pairsList, turnSettings) > 0)
            {
                //Llenar con random
                int randomIndex = UnityEngine.Random.Range(0, miscellaneousCards.Count);
                var randomCard = miscellaneousCards[randomIndex];// Suponiendo que tienes una función que retorna una carta aleatoria
                AddCardToPair(pairsList, randomCard.card);
            }
        }
        
        private int IsPairListFillingNeeded(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings)
        {
            int totalCardsNeeded = turnSettings.cardsInTurn;
            int totalCardsAdded = pairsList.Sum(pair => (pair.First != null ? 1 : 0) + (pair.Second != null ? 1 : 0));
            return totalCardsNeeded - totalCardsAdded;
        }
        
        private void UpdateMaxCardsInPlayForTurn(int turnIndex)
        {
            // Recorrer todas las cartas disponibles y actualizar maxCardsInPlay según el turno.
            foreach (var pair in cardRepartitionData.availableCards)
            {
                foreach (var card in pair.Value)
                {
                    var turns = card.initialTurns.Where(it => it.initialTurn <= turnIndex);
    
                    float maxCardsAllowed = 0;
                    
                    if (turns.Any())
                    {
                        maxCardsAllowed = turns.Max(it => it.maxCardsAllowed);
                    }
    
                    card.maxCardsInPlay = (int)maxCardsAllowed;
                }
            }
        }
        
        public void CardPlacedOnBoard(int cardId)
        {
            var cardInfo = FindCardInfoById(cardId);
            if (cardInfo != null)
            {
                if(timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] += 1;
                else timesCardPlaced.Add(cardId, 1);
                cardInfo.currentCardsInPlay = timesCardPlaced[cardId];
            }
        }
    
        public void CardRemovedFromBoard(int cardId)
        {
            var cardInfo = FindCardInfoById(cardId);
            if (cardInfo != null)
            {
                if (timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] -= 1;
                else timesCardPlaced.Add(cardId, 0);
                cardInfo.currentCardsInPlay = Mathf.Max(0, timesCardPlaced[cardId]);
            }
        }
    
        private CardInfo FindCardInfoById(int cardId)
        {
            CardInfo cardInfo;
            // Intenta obtener la información de la carta asociada al GameObject.
            if (gameObjectToCardInfoMap.TryGetValue(cardId, out cardInfo))
            {
                return cardInfo; // Retorna la información de la carta si se encuentra.
            }
    
            return null; // Retorna null si no se encuentra una asociación.
        }
        
        private void AssociateCardsWithGameObjects()
        {
            foreach (var collectionPair in cardRepartitionData.availableCards)
            {
                List<CardInfo> cardsList = collectionPair.Value;
                foreach (var cardInfo in cardsList)
                {
                    if (cardInfo.card != null)
                    {
                        gameObjectToCardInfoMap.TryAdd(cardInfo.card.GetComponent<CardBase>().id, cardInfo);
                    }
                }
            }
        }
    
        private void FillCardsInPlay()
        {
            foreach (var collectionPair in gameObjectToCardInfoMap)
            {
                if (!timesCardPlaced.ContainsKey(collectionPair.Key)) timesCardPlaced.Add(collectionPair.Key, 0);
                collectionPair.Value.currentCardsInPlay = timesCardPlaced[collectionPair.Key];
            }
            
        }
        
        public void UnpairDuplicates(List<Pair<GameObject>> selectedCardPairs)
        {
            // Identificar y corregir pares con cartas repetidas.
            for (int i = 0; i < selectedCardPairs.Count; i++)
            {
                Pair<GameObject> currentPair = selectedCardPairs[i];
        
                // Verificar si el par actual tiene cartas idénticas.
                if (currentPair.First.name == currentPair.Second.name)
                {
                    // Buscar otro par para hacer el intercambio.
                    for (int j = 0; j < selectedCardPairs.Count; j++)
                    {
                        if (i != j) // Asegurarse de que no es el mismo par.
                        {
                            Pair<GameObject> potentialPair = selectedCardPairs[j];
    
                            // Asegurar que no estamos creando otro par de cartas repetidas al intercambiar.
                            if (potentialPair.First != currentPair.First && potentialPair.Second != currentPair.First)
                            {
                                // Realizar el intercambio de una de las cartas.
                                GameObject temp = currentPair.Second;
                                currentPair.Second = potentialPair.Second;
                                potentialPair.Second = temp;
                        
                                // Salir del ciclo una vez realizado el intercambio satisfactorio.
                                break;
                            }
                        }
                    }
                }
            }
        }
        
        public int CountCardInfo(List<CardInfo> cardList, CardInfo targetCardInfo)
        {
            return cardList.Count(cardInfo => cardInfo == targetCardInfo);
        }
        
        private int CountCardPair(List<Pair<GameObject>> cardList, CardInfo targetCardInfo)
        {
            int count = 0;
            foreach (var pair in cardList)
            {
                if (pair.First == targetCardInfo.card)
                {
                    count++;
                }
                if (pair.Second == targetCardInfo.card)
                {
                    count++;
                }
            }
            return count;
        }
    
        
        
    }
    

    }

  2. Assistant

    Para ajustar la función FillWithMiscellaneous para que las cartas no se distribuyan de manera totalmente aleatoria y evitar la repetición excesiva, podemos ajustar la lógica para considerar la frecuencia con la que ya se ha distribuido cada carta.

    Aquí hay algunas sugerencias para hacer esto:

    1. Registro de Frecuencia de Cartas: Llevar un registro de cuántas veces se ha colocado cada carta en la sesión actual.
    2. Ajuste de Probabilidad de Selección: Ajustar la probabilidad de selección de las cartas basándose en cuántas veces ya se han colocado para favorecer más aquellas que no han sido seleccionadas recientemente.
    3. Lógica de Selección: Seleccionar cartas considerando tanto la probabilidad ajustada como la frecuencia de aparición actual.

    A continuación, se muestra cómo podrías hacer estos cambios en tu código:

    using System;
    using Cards;
    using UnityEngine.Serialization;
    
    namespace Game.Systems
    {
        using System.Collections.Generic;
        using System.Linq;
        using UnityEngine;
    
        [System.Serializable]
        public class Pair<Card>
        {
            public Card First;
            public Card Second;
        }
    
        public class CardSelector : MonoBehaviour
        {
            [SerializeField] CardRepartitionData cardRepartitionDataScriptable;
            private CardRepartitionData cardRepartitionData;
            private System.Random random = new System.Random();
            private Dictionary<int, CardInfo> gameObjectToCardInfoMap = new Dictionary<int, CardInfo>();
            public Dictionary<int, int> timesCardPlaced = new Dictionary<int, int>();
    
            public void Init()
            {
                cardRepartitionData = CloneScriptableObject.Clone<CardRepartitionData>(cardRepartitionDataScriptable);
                AssociateCardsWithGameObjects();
                FillCardsInPlay();
            }
            
            public List<Pair<GameObject>> GenerateCardPairsForTurn(int turnIndex)
            {
                var selectedCardPairs = new List<Pair<GameObject>>();
                
                if (turnIndex >= GetTurnsCount())
                {
                    Debug.LogError("Turn index out of range.");
                    return selectedCardPairs;
                }
    
                UpdateMaxCardsInPlayForTurn(turnIndex);
                
                TurnRepartition turnSettings = cardRepartitionData.turns[turnIndex];
    
                // Respeta las cartas fijas
                EnsurePairListSize(selectedCardPairs, turnSettings.cardsInTurn / 2);
                
                AddFixedCardsToPairs(turnSettings, selectedCardPairs);
                
                // Selecciona cartas por colecciones específicas
                var selectedCardsByCollection = SelectCardsByCollection(selectedCardPairs, turnSettings, turnIndex);
                foreach (var cardInfo in selectedCardsByCollection)
                {
                    AddCardToPair(selectedCardPairs, cardInfo.card);
                }
    
                // Rellenar pares adicionales si es necesario, según cardsInTurn
                FillWithMiscellaneous(selectedCardPairs, turnSettings, turnIndex);
    
                UnpairDuplicates(selectedCardPairs);
                
                return selectedCardPairs;
            }
    
            public int GetTurnsCount()
            {
                return cardRepartitionData.turns.Count;
            }
    
            private void AddFixedCardsToPairs(TurnRepartition turnSettings, List<Pair<GameObject>> pairsList)
            {
                foreach (var fixedCard in turnSettings.fixedCards.OrderBy(c => c.index))
                {
                    // Asegurar que la lista tenga un tamaño adecuado
                    Pair<GameObject> pairAtFixedIndex = pairsList[fixedCard.index];
                    
                    // Si First y Second ya están asignados, ignora las cartas adicionales con el mismo índice.
                    if (pairAtFixedIndex.First == null)
                    {
                        pairAtFixedIndex.First = fixedCard.card;
                    }
                    else if (pairAtFixedIndex.Second == null)
                    {
                        pairAtFixedIndex.Second = fixedCard.card;
                    }
                }
            }
    
            public struct CardWithAdjustedProb
            {
                public CardInfo Card;
                public float probability;
            }
            
            private CardInfo DrawWeightedRandomCard(List<CardInfo> cardList, int turnIndex)
            {
                List<CardWithAdjustedProb> tempCardListWithAdjustedProb = new List<CardWithAdjustedProb>();
    
                foreach (var card in cardList)
                {
                
                    List<InitialTurns> sortedList = card.initialTurns.OrderBy(it => it.initialTurn).ToList();
                    
                    foreach (var it in sortedList)
                    {
                        if(it.initialTurn <= turnIndex && card.currentCardsInPlay < it.maxCardsAllowed)
                        {
                            tempCardListWithAdjustedProb.Add(new CardWithAdjustedProb
                            {
                                Card = card,
                                probability = it.probability
                            });
                            
                            break;
                        }
                    }
                }
                
                
                float totalWeight = tempCardListWithAdjustedProb.Sum(c => c.probability);
        
                float randomNumber = (float)random.NextDouble() * totalWeight;
    
                float accumulatedProbability = 0;
                foreach (var item in tempCardListWithAdjustedProb)
                {
                    accumulatedProbability += item.probability;
                    if (randomNumber <= accumulatedProbability)
                    {
                        return item.Card;
                    }
                }
    
                return null; // En caso de no encontrar una carta adecuada.
            }
    
            
            private void EnsurePairListSize(List<Pair<GameObject>> list, int size)
            {
                while (list.Count < size)
                {
                    list.Add(new Pair<GameObject>());
                }
            }
            
            private List<CardInfo> GetAllAvailableCardsForTurn(TurnRepartition turnSettings, int turnIndex)
            {
                List<CardInfo> result = new List<CardInfo>();
                foreach (var collection in cardRepartitionData.availableCards)
                {
                    foreach (var card in collection.Value)
                    {
                        List<InitialTurns> initialTurns = new List<InitialTurns>();
                        
                        foreach (var turnInfo in card.initialTurns)
                        {
                            if (turnInfo.initialTurn <= turnIndex) // Carta está disponible
                            {
                                initialTurns.Add(turnInfo);
                            }
                            
                        }
    
                        if (initialTurns.Count > 0)
                        {
                            var newCardInfo = new CardInfo()
                            {
                                card = card.card, 
                                collection = card.collection,
                                maxCopiesInTurn = card.maxCopiesInTurn, 
                                initialTurns = initialTurns, 
                                remainingCopies = card.maxCopiesInTurn,
                                maxCardsInPlay = card.maxCardsInPlay,
                                currentCardsInPlay = card.currentCardsInPlay
                            };
                            
                            result.Add(newCardInfo);
                        }
    
                    }
                }
                return result;
            }
            
            private List<CardInfo> SelectCardsByCollection(List<Pair<GameObject>> selectedCardPairs,
                TurnRepartition turnSettings, int turnIndex)
            {
                List<CardInfo> selectedCards = new List<CardInfo>();
    
                foreach (var collectionEntry in turnSettings.cardsPerCollection)
                {
                    var cardsAvailable = GetAllAvailableCardsForTurn(turnSettings, turnIndex);
    
                    List<CardInfo> cardsInThisCollection = new List<CardInfo>();
    
                    foreach (var card in cardsAvailable)
                    {
                        if (card.collection == collectionEntry.Key)
                        {
                            cardsInThisCollection.Add(card);
                        }
                    }
                    
                    List<CardInfo> sortedCards = new List<CardInfo>();
                        
                    if (cardsInThisCollection.Any())
                    {
                        sortedCards = cardsInThisCollection.OrderBy(card => card.initialTurns.Min(it => it.initialTurn)).ToList();
                    }
                    else
                    {
                        continue;
                    }
    
                    int cardsToSelect = collectionEntry.Value;
    
                    List<CardInfo> copySortedCards = new List<CardInfo>(sortedCards);
                    
                    foreach (var card in copySortedCards)
                    {
                        if (card.currentCardsInPlay >= card.maxCardsInPlay)
                        {
                            sortedCards.Remove(card);
                        }
                        else if (card.maxCardsInPlay - card.currentCardsInPlay < card.remainingCopies)
                        {
                            card.remainingCopies = card.maxCardsInPlay - card.currentCardsInPlay;
                        }
    
                        if (CountCardPair(selectedCardPairs, card) >= card.maxCopiesInTurn)
                        {
                            sortedCards.Remove(card);
                        }
                    }
    
                    while (cardsToSelect > 0 && sortedCards.Any())
                    {
                        CardInfo selectedCard = DrawWeightedRandomCard(sortedCards, turnIndex);
                        if (selectedCard != null)
                        {
                            selectedCards.Add(selectedCard);
                            selectedCard.remainingCopies -= 1;
    
                            if (selectedCard.remainingCopies <= 0)
                            {
                                sortedCards.Remove(selectedCard);
                            }
    
                            if (CountCardPair(selectedCardPairs, selectedCard) >= selectedCard.maxCopiesInTurn)
                            {
                                sortedCards.Remove(selectedCard);
                            }
                            
                            cardsToSelect--;
                        }
                    }
                }
    
                return selectedCards;
            }
            
            private void AddCardToPair(List<Pair<GameObject>> pairsList, GameObject cardToAdd)
            {
                System.Random rng = new System.Random(); 
                
                var emptyFirstPairs = pairsList.Where(pair => pair.First == null).ToList();
    
                if (emptyFirstPairs.Count > 0)
                {
                    int randomIndex = rng.Next(emptyFirstPairs.Count);
                    emptyFirstPairs[randomIndex].First = cardToAdd;
                }
                else
                {
                    var secondNullPairs = pairsList.Where(pair => pair.Second == null).ToList();
                    if (secondNullPairs.Count > 0)
                    {
                        int randomIndex = rng.Next(secondNullPairs.Count);
                        secondNullPairs[randomIndex].Second = cardToAdd;
                    }
                    else
                    {
                        var newPair = new Pair<GameObject>() { First = cardToAdd };
                        pairsList.Add(newPair);
                    }
                }
    
            }
            
            private Dictionary<CardColection, float> CalculateUrgencyScores(TurnRepartition turnSettings, Expectations currentState)
            {
                var urgencyScores = new Dictionary<CardColection, float>();
    
                urgencyScores[CardColection.Gold] = (turnSettings.expectations.gold - currentState.gold) / (float)turnSettings.expectations.gold;
                urgencyScores[CardColection.Wood] = (turnSettings.expectations.wood - currentState.wood) / (float)turnSettings.expectations.wood;
                urgencyScores[CardColection.Food] = (turnSettings.expectations.food - currentState.food) / (float)turnSettings.expectations.food;
                urgencyScores[CardColection.Stone] = (turnSettings.expectations.stone - currentState.stone) / (float)turnSettings.expectations.stone;
                urgencyScores[CardColection.Population] = (turnSettings.expectations.population - currentState.population) / (float)turnSettings.expectations.population;
                
                return urgencyScores;
            }
            
            private void FillWithMiscellaneous(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings, int turnIndex)
            {
                var miscellaneousCards = GetAllAvailableCardsForTurn(turnSettings, turnIndex)
                    .Where(card => card.collection == CardColection.Miscellaneous).ToList();
    
                EnsurePairListSize(pairsList, turnSettings.cardsInTurn / 2);
    
                // Generar una lista con la probabilidad ajustada de cada carta
                List<CardWithAdjustedProb> cardProbs = new List<CardWithAdjustedProb>();
                foreach (var card in miscellaneousCards)
                {
                    if (card.currentCardsInPlay < card.maxCardsInPlay)
                    {
                        float adjustedProbability = 1f / (1 + timesCardPlaced.GetValueOrDefault(card.card.GetComponent<CardBase>().id, 0));
                        cardProbs.Add(new CardWithAdjustedProb
                        {
                            Card = card,
                            probability = adjustedProbability
                        });
                    }
                }
    
                // Normalizar las probabilidades
                float totalWeight = cardProbs.Sum(c => c.probability);
                foreach (var cardProb in cardProbs)
                {
                    cardProb.probability = cardProb.probability / totalWeight;
                }
    
                // Llenar los pares restantes con cartas misceláneas con base en las probabilidades ajustadas
                while (IsPairListFillingNeeded(pairsList, turnSettings) > 0)
                {
                    float randomNumber = (float)random.NextDouble();
                    float accumulatedProbability = 0;
                    CardInfo selectedCard = null;
    
                    foreach (var cardProb in cardProbs)
                    {
                        accumulatedProbability += cardProb.probability;
                        if (randomNumber <= accumulatedProbability)
                        {
                            selectedCard = cardProb.Card;
                            break;
                        }
                    }
    
                    if (selectedCard != null)
                    {
                        AddCardToPair(pairsList, selectedCard.card);
                        timesCardPlaced[selectedCard.card.GetComponent<CardBase>().id]++;
                        if(timesCardPlaced[selectedCard.card.GetComponent<CardBase>().id] >= selectedCard.maxCardsInPlay)
                        {
                            cardProbs.RemoveAll(c => c.Card == selectedCard);
                        }
                    }
                }
            }
            
            private int IsPairListFillingNeeded(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings)
            {
                int totalCardsNeeded = turnSettings.cardsInTurn;
                int totalCardsAdded = pairsList.Sum(pair => (pair.First != null ? 1 : 0) + (pair.Second != null ? 1 : 0));
                return totalCardsNeeded - totalCardsAdded;
            }
            
            private void UpdateMaxCardsInPlayForTurn(int turnIndex)
            {
                foreach (var pair in cardRepartitionData.availableCards)
                {
                    foreach (var card in pair.Value)
                    {
                        var turns = card.initialTurns.Where(it => it.initialTurn <= turnIndex);
    
                        float maxCardsAllowed = 0;
                        
                        if (turns.Any())
                        {
                            maxCardsAllowed = turns.Max(it => it.maxCardsAllowed);
                        }
    
                        card.maxCardsInPlay = (int)maxCardsAllowed;
                    }
                }
            }
            
            public void CardPlacedOnBoard(int cardId)
            {
                var cardInfo = FindCardInfoById(cardId);
                if (cardInfo != null)
                {
                    if(timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] += 1;
                    else timesCardPlaced.Add(cardId, 1);
                    cardInfo.currentCardsInPlay = timesCardPlaced[cardId];
                }
            }
    
            public void CardRemovedFromBoard(int cardId)
            {
                var cardInfo = FindCardInfoById(cardId);
                if (cardInfo != null)
                {
                    if (timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] -= 1;
                    else timesCardPlaced.Add(cardId, 0);
                    cardInfo.currentCardsInPlay = Mathf.Max(0, timesCardPlaced[cardId]);
                }
            }
    
            private CardInfo FindCardInfoById(int cardId)
            {
                CardInfo cardInfo;
                if (gameObjectToCardInfoMap.TryGetValue(cardId, out cardInfo))
                {
                    return cardInfo;
                }
    
                return null;
            }
            
            private void AssociateCardsWithGameObjects()
            {
                foreach (var collectionPair in cardRepartitionData.availableCards)
                {
                    List<CardInfo> cardsList = collectionPair.Value;
                    foreach (var cardInfo in cardsList)
                    {
                        if (cardInfo.card != null)
                        {
                            gameObjectToCardInfoMap.TryAdd(cardInfo.card.GetComponent<CardBase>().id, cardInfo);
                        }
                    }
                }
            }
    
            private void FillCardsInPlay()
            {
                foreach (var collectionPair in gameObjectToCardInfoMap)
                {
                    if (!timesCardPlaced.ContainsKey(collectionPair.Key)) timesCardPlaced.Add(collectionPair.Key, 0);
                    collectionPair.Value.currentCardsInPlay = timesCardPlaced[collectionPair.Key];
                }
                
            }
            
            public void UnpairDuplicates(List<Pair<GameObject>> selectedCardPairs)
            {
                for (int i = 0; i < selectedCardPairs.Count; i++)
                {
                    Pair<GameObject> currentPair = selectedCardPairs[i];
            
                    if (currentPair.First.name == currentPair.Second.name)
                    {
                        for (int j = 0; j < selectedCardPairs.Count; j++)
                        {
                            if (i != j)
                            {
                                Pair<GameObject> potentialPair = selectedCardPairs[j];
    
                                if (potentialPair.First != currentPair.First && potentialPair.Second != currentPair.First)
                                {
                                    GameObject temp = currentPair.Second;
                                    currentPair.Second = potentialPair.Second;
                                    potentialPair.Second = temp;
                            
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            
            public int CountCardInfo(List<CardInfo> cardList, CardInfo targetCardInfo)
            {
                return cardList.Count(cardInfo => cardInfo == targetCardInfo);
            }
            
            private int CountCardPair(List<Pair<GameObject>> cardList, CardInfo targetCardInfo)
            {
                int count = 0;
                foreach (var pair in cardList)
                {
                    if (pair.First == targetCardInfo.card)
                    {
                        count++;
                    }
                    if (pair.Second == targetCardInfo.card)
                    {
                        count++;
                    }
                }
                return count;
            }
        }
    }
    

    Cambios Clave:

    1. Registro de Frecuencia de Cartas:

      • timesCardPlaced se usa para mantener un registro de cuántas veces se ha colocado cada carta.
    2. Ajuste de Probabilidades en FillWithMiscellaneous:

      • Ajustamos la probabilidad de selección de las cartas misceláneas usando una fórmula inversa (1 / (1 + timesCardPlaced.GetValueOrDefault(card.card.GetComponent<CardBase>().id, 0))), lo que favorece las cartas que no se han seleccionado frecuentemente.
    3. Remoción de Cartas Pleno Uso:

      • Aseguramos que una carta seleccione debido a su uso alcance su maxCardsInPlay es removido de futuras selecciones.

    Estos cambios deberían ayudar a distribuir las cartas de manera más equitativa y reducir la probabilidad de repetición.

  3. User

    No, pero quiero que tomes en cuenta solo este turno, no los anteriores, timescardplaced toma en cuenta turnos anteriores

  4. Assistant

    Entiendo, quieres ajustar la lógica para que cada turno las cartas misceláneas se distribuyan de manera más uniforme sin considerar los turnos anteriores. En este caso, podemos modificar la función FillWithMiscellaneous para rastrear y ajustar la probabilidad de selección de las cartas dentro de un turno individual.

    Aquí tienes el código ajustado para asegurar una distribución más equilibrada dentro de un solo turno:

    using System;
    using Cards;
    using UnityEngine.Serialization;
    
    namespace Game.Systems
    {
        using System.Collections.Generic;
        using System.Linq;
        using UnityEngine;
    
        [System.Serializable]
        public class Pair<Card>
        {
            public Card First;
            public Card Second;
        }
    
        public class CardSelector : MonoBehaviour
        {
            [SerializeField] CardRepartitionData cardRepartitionDataScriptable;
            private CardRepartitionData cardRepartitionData;
            private System.Random random = new System.Random();
            private Dictionary<int, CardInfo> gameObjectToCardInfoMap = new Dictionary<int, CardInfo>();
            public Dictionary<int, int> timesCardPlaced = new Dictionary<int, int>();
    
            public void Init()
            {
                cardRepartitionData = CloneScriptableObject.Clone<CardRepartitionData>(cardRepartitionDataScriptable);
                AssociateCardsWithGameObjects();
                FillCardsInPlay();
            }
            
            public List<Pair<GameObject>> GenerateCardPairsForTurn(int turnIndex)
            {
                var selectedCardPairs = new List<Pair<GameObject>>();
                
                if (turnIndex >= GetTurnsCount())
                {
                    Debug.LogError("Turn index out of range.");
                    return selectedCardPairs;
                }
    
                UpdateMaxCardsInPlayForTurn(turnIndex);
                
                TurnRepartition turnSettings = cardRepartitionData.turns[turnIndex];
    
                // Respeta las cartas fijas
                EnsurePairListSize(selectedCardPairs, turnSettings.cardsInTurn / 2);
                
                AddFixedCardsToPairs(turnSettings, selectedCardPairs);
                
                // Selecciona cartas por colecciones específicas
                var selectedCardsByCollection = SelectCardsByCollection(selectedCardPairs, turnSettings, turnIndex);
                foreach (var cardInfo in selectedCardsByCollection)
                {
                    AddCardToPair(selectedCardPairs, cardInfo.card);
                }
    
                // Rellenar pares adicionales si es necesario, según cardsInTurn
                FillWithMiscellaneous(selectedCardPairs, turnSettings, turnIndex);
    
                UnpairDuplicates(selectedCardPairs);
                
                return selectedCardPairs;
            }
    
            public int GetTurnsCount()
            {
                return cardRepartitionData.turns.Count;
            }
    
            private void AddFixedCardsToPairs(TurnRepartition turnSettings, List<Pair<GameObject>> pairsList)
            {
                foreach (var fixedCard in turnSettings.fixedCards.OrderBy(c => c.index))
                {
                    // Asegurar que la lista tenga un tamaño adecuado
                    Pair<GameObject> pairAtFixedIndex = pairsList[fixedCard.index];
                    
                    // Si First y Second ya están asignados, ignora las cartas adicionales con el mismo índice.
                    if (pairAtFixedIndex.First == null)
                    {
                        pairAtFixedIndex.First = fixedCard.card;
                    }
                    else if (pairAtFixedIndex.Second == null)
                    {
                        pairAtFixedIndex.Second = fixedCard.card;
                    }
                }
            }
    
            public struct CardWithAdjustedProb
            {
                public CardInfo Card;
                public float probability;
            }
            
            private CardInfo DrawWeightedRandomCard(List<CardInfo> cardList, int turnIndex)
            {
                List<CardWithAdjustedProb> tempCardListWithAdjustedProb = new List<CardWithAdjustedProb>();
    
                foreach (var card in cardList)
                {
                
                    List<InitialTurns> sortedList = card.initialTurns.OrderBy(it => it.initialTurn).ToList();
                    
                    foreach (var it in sortedList)
                    {
                        if(it.initialTurn <= turnIndex && card.currentCardsInPlay < it.maxCardsAllowed)
                        {
                            tempCardListWithAdjustedProb.Add(new CardWithAdjustedProb
                            {
                                Card = card,
                                probability = it.probability
                            });
                            
                            break;
                        }
                    }
                }
                
                
                float totalWeight = tempCardListWithAdjustedProb.Sum(c => c.probability);
        
                float randomNumber = (float)random.NextDouble() * totalWeight;
    
                float accumulatedProbability = 0;
                foreach (var item in tempCardListWithAdjustedProb)
                {
                    accumulatedProbability += item.probability;
                    if (randomNumber <= accumulatedProbability)
                    {
                        return item.Card;
                    }
                }
    
                return null; // En caso de no encontrar una carta adecuada.
            }
    
            
            private void EnsurePairListSize(List<Pair<GameObject>> list, int size)
            {
                while (list.Count < size)
                {
                    list.Add(new Pair<GameObject>());
                }
            }
            
            private List<CardInfo> GetAllAvailableCardsForTurn(TurnRepartition turnSettings, int turnIndex)
            {
                List<CardInfo> result = new List<CardInfo>();
                foreach (var collection in cardRepartitionData.availableCards)
                {
                    foreach (var card in collection.Value)
                    {
                        List<InitialTurns> initialTurns = new List<InitialTurns>();
                        
                        foreach (var turnInfo in card.initialTurns)
                        {
                            if (turnInfo.initialTurn <= turnIndex) // Carta está disponible
                            {
                                initialTurns.Add(turnInfo);
                            }
                            
                        }
    
                        if (initialTurns.Count > 0)
                        {
                            var newCardInfo = new CardInfo()
                            {
                                card = card.card, 
                                collection = card.collection,
                                maxCopiesInTurn = card.maxCopiesInTurn, 
                                initialTurns = initialTurns, 
                                remainingCopies = card.maxCopiesInTurn,
                                maxCardsInPlay = card.maxCardsInPlay,
                                currentCardsInPlay = card.currentCardsInPlay
                            };
                            
                            result.Add(newCardInfo);
                        }
    
                    }
                }
                return result;
            }
            
            private List<CardInfo> SelectCardsByCollection(List<Pair<GameObject>> selectedCardPairs,
                TurnRepartition turnSettings, int turnIndex)
            {
                List<CardInfo> selectedCards = new List<CardInfo>();
    
                foreach (var collectionEntry in turnSettings.cardsPerCollection)
                {
                    var cardsAvailable = GetAllAvailableCardsForTurn(turnSettings, turnIndex);
    
                    List<CardInfo> cardsInThisCollection = new List<CardInfo>();
    
                    foreach (var card in cardsAvailable)
                    {
                        if (card.collection == collectionEntry.Key)
                        {
                            cardsInThisCollection.Add(card);
                        }
                    }
                    
                    List<CardInfo> sortedCards = new List<CardInfo>();
                        
                    if (cardsInThisCollection.Any())
                    {
                        sortedCards = cardsInThisCollection.OrderBy(card => card.initialTurns.Min(it => it.initialTurn)).ToList();
                    }
                    else
                    {
                        continue;
                    }
    
                    int cardsToSelect = collectionEntry.Value;
    
                    List<CardInfo> copySortedCards = new List<CardInfo>(sortedCards);
                    
                    foreach (var card in copySortedCards)
                    {
                        if (card.currentCardsInPlay >= card.maxCardsInPlay)
                        {
                            sortedCards.Remove(card);
                        }
                        else if (card.maxCardsInPlay - card.currentCardsInPlay < card.remainingCopies)
                        {
                            card.remainingCopies = card.maxCardsInPlay - card.currentCardsInPlay;
                        }
    
                        if (CountCardPair(selectedCardPairs, card) >= card.maxCopiesInTurn)
                        {
                            sortedCards.Remove(card);
                        }
                    }
    
                    while (cardsToSelect > 0 && sortedCards.Any())
                    {
                        CardInfo selectedCard = DrawWeightedRandomCard(sortedCards, turnIndex);
                        if (selectedCard != null)
                        {
                            selectedCards.Add(selectedCard);
                            selectedCard.remainingCopies -= 1;
    
                            if (selectedCard.remainingCopies <= 0)
                            {
                                sortedCards.Remove(selectedCard);
                            }
    
                            if (CountCardPair(selectedCardPairs, selectedCard) >= selectedCard.maxCopiesInTurn)
                            {
                                sortedCards.Remove(selectedCard);
                            }
                            
                            cardsToSelect--;
                        }
                    }
                }
    
                return selectedCards;
            }
            
            private void AddCardToPair(List<Pair<GameObject>> pairsList, GameObject cardToAdd)
            {
                System.Random rng = new System.Random(); 
                
                var emptyFirstPairs = pairsList.Where(pair => pair.First == null).ToList();
    
                if (emptyFirstPairs.Count > 0)
                {
                    int randomIndex = rng.Next(emptyFirstPairs.Count);
                    emptyFirstPairs[randomIndex].First = cardToAdd;
                }
                else
                {
                    var secondNullPairs = pairsList.Where(pair => pair.Second == null).ToList();
                    if (secondNullPairs.Count > 0)
                    {
                        int randomIndex = rng.Next(secondNullPairs.Count);
                        secondNullPairs[randomIndex].Second = cardToAdd;
                    }
                    else
                    {
                        var newPair = new Pair<GameObject>() { First = cardToAdd };
                        pairsList.Add(newPair);
                    }
                }
    
            }
            
            private Dictionary<CardColection, float> CalculateUrgencyScores(TurnRepartition turnSettings, Expectations currentState)
            {
                var urgencyScores = new Dictionary<CardColection, float>();
    
                urgencyScores[CardColection.Gold] = (turnSettings.expectations.gold - currentState.gold) / (float)turnSettings.expectations.gold;
                urgencyScores[CardColection.Wood] = (turnSettings.expectations.wood - currentState.wood) / (float)turnSettings.expectations.wood;
                urgencyScores[CardColection.Food] = (turnSettings.expectations.food - currentState.food) / (float)turnSettings.expectations.food;
                urgencyScores[CardColection.Stone] = (turnSettings.expectations.stone - currentState.stone) / (float)turnSettings.expectations.stone;
                urgencyScores[CardColection.Population] = (turnSettings.expectations.population - currentState.population) / (float)turnSettings.expectations.population;
                
                return urgencyScores;
            }
            
            private void FillWithMiscellaneous(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings, int turnIndex)
            {
                var miscellaneousCards = GetAllAvailableCardsForTurn(turnSettings, turnIndex)
                    .Where(card => card.collection == CardColection.Miscellaneous).ToList();
    
                EnsurePairListSize(pairsList, turnSettings.cardsInTurn / 2);
    
                // Mantiene un contador de cuántas veces se ha colocado cada carta en este turno
                var cardsInThisTurn = new Dictionary<CardInfo, int>();
    
                // Llenar los pares restantes con cartas misceláneas
                while (IsPairListFillingNeeded(pairsList, turnSettings) > 0)
                {
                    List<CardWithAdjustedProb> cardProbs = new List<CardWithAdjustedProb>();
    
                    foreach (var card in miscellaneousCards)
                    {
                        if (card.currentCardsInPlay < card.maxCardsInPlay)
                        {
                            int placedInThisTurn = cardsInThisTurn.GetValueOrDefault(card, 0);
                            float adjustedProbability = 1f / (1 + placedInThisTurn);
                            cardProbs.Add(new CardWithAdjustedProb
                            {
                                Card = card,
                                probability = adjustedProbability
                            });
                        }
                    }
    
                    float totalWeight = cardProbs.Sum(c => c.probability);
                    foreach (var cardProb in cardProbs)
                    {
                        cardProb.probability = cardProb.probability / totalWeight;
                    }
    
                    float randomNumber = (float)random.NextDouble();
                    float accumulatedProbability = 0;
                    CardInfo selectedCard = null;
    
                    foreach (var cardProb in cardProbs)
                    {
                        accumulatedProbability += cardProb.probability;
                        if (randomNumber <= accumulatedProbability)
                        {
                            selectedCard = cardProb.Card;
                            break;
                        }
                    }
    
                    if (selectedCard != null)
                    {
                        AddCardToPair(pairsList, selectedCard.card);
                        cardsInThisTurn[selectedCard] = cardsInThisTurn.GetValueOrDefault(selectedCard, 0) + 1;
                        selectedCard.currentCardsInPlay++;
                        if (selectedCard.currentCardsInPlay >= selectedCard.maxCardsInPlay)
                        {
                            miscellaneousCards.Remove(selectedCard);
                        }
                    }
                }
            }
            
            private int IsPairListFillingNeeded(List<Pair<GameObject>> pairsList, TurnRepartition turnSettings)
            {
                int totalCardsNeeded = turnSettings.cardsInTurn;
                int totalCardsAdded = pairsList.Sum(pair => (pair.First != null ? 1 : 0) + (pair.Second != null ? 1 : 0));
                return totalCardsNeeded - totalCardsAdded;
            }
            
            private void UpdateMaxCardsInPlayForTurn(int turnIndex)
            {
                foreach (var pair in cardRepartitionData.availableCards)
                {
                    foreach (var card in pair.Value)
                    {
                        var turns = card.initialTurns.Where(it => it.initialTurn <= turnIndex);
    
                        float maxCardsAllowed = 0;
                        
                        if (turns.Any())
                        {
                            maxCardsAllowed = turns.Max(it => it.maxCardsAllowed);
                        }
    
                        card.maxCardsInPlay = (int)maxCardsAllowed;
                    }
                }
            }
            
            public void CardPlacedOnBoard(int cardId)
            {
                var cardInfo = FindCardInfoById(cardId);
                if (cardInfo != null)
                {
                    if(timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] += 1;
                    else timesCardPlaced.Add(cardId, 1);
                    cardInfo.currentCardsInPlay = timesCardPlaced[cardId];
                }
            }
    
            public void CardRemovedFromBoard(int cardId)
            {
                var cardInfo = FindCardInfoById(cardId);
                if (cardInfo != null)
                {
                    if (timesCardPlaced.ContainsKey(cardId)) timesCardPlaced[cardId] -= 1;
                    else timesCardPlaced.Add(cardId, 0);
                    cardInfo.currentCardsInPlay = Mathf.Max(0, timesCardPlaced[cardId]);
                }
            }
    
            private CardInfo FindCardInfoById(int cardId)
            {
                CardInfo cardInfo;
                if (gameObjectToCardInfoMap.TryGetValue(cardId, out cardInfo))
                {
                    return cardInfo;
                }
    
                return null;
            }
            
            private void AssociateCardsWithGameObjects()
            {
                foreach (var collectionPair in cardRepartitionData.availableCards)
                {
                    List<CardInfo> cardsList = collectionPair.Value;
                    foreach (var cardInfo in cardsList)
                    {
                        if (cardInfo.card != null)
                        {
                            gameObjectToCardInfoMap.TryAdd(cardInfo.card.GetComponent<CardBase>().id, cardInfo);
                        }
                    }
                }
            }
    
            private void FillCardsInPlay()
            {
                foreach (var collectionPair in gameObjectToCardInfoMap)
                {
                    if (!timesCardPlaced.ContainsKey(collectionPair.Key)) timesCardPlaced.Add(collectionPair.Key, 0);
                    collectionPair.Value.currentCardsInPlay = timesCardPlaced[collectionPair.Key];
                }
                
            }
            
            public void UnpairDuplicates(List<Pair<GameObject>> selectedCardPairs)
            {
                for (int i = 0; i < selectedCardPairs.Count; i++)
                {
                    Pair<GameObject> currentPair = selectedCardPairs[i];
            
                    if (currentPair.First.name == currentPair.Second.name)
                    {
                        for (int j = 0; j < selectedCardPairs.Count; j++)
                        {
                            if (i != j)
                            {
                                Pair<GameObject> potentialPair = selectedCardPairs[j];
    
                                if (potentialPair.First != currentPair.First && potentialPair.Second != currentPair.First)
                                {
                                    GameObject temp = currentPair.Second;
                                    currentPair.Second = potentialPair.Second;
                                    potentialPair.Second = temp;
                            
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            
            public int CountCardInfo(List<CardInfo> cardList, CardInfo targetCardInfo)
            {
                return cardList.Count(cardInfo => cardInfo == targetCardInfo);
            }
            
            private int CountCardPair(List<Pair<GameObject>> cardList, CardInfo targetCardInfo)
            {
                int count = 0;
                foreach (var pair in cardList)
                {
                    if (pair.First == targetCardInfo.card)
                    {
                        count++;
                    }
                    if (pair.Second == targetCardInfo.card)
                    {
                        count++;
                    }
                }
                return count;
            }
        }
    }
    

    Cambios Clave:

    1. Registro de Frecuencia de Cartas en el Turno:

      • Se ha añadido un diccionario cardsInThisTurn para rastrear cuántas veces se ha colocado cada carta dentro del turno actual.
    2. Ajuste de Probabilidades en FillWithMiscellaneous:

      • Las probabilidades de seleccionar cartas se ajustan dinámicamente durante el turno actual usando 1 / (1 + placedInThisTurn).
    3. Actualización de currentCardsInPlay:

      • Se incrementa currentCardsInPlay y se elimina la carta de la lista si se alcanza el máximo permitido en el turno actual.

    Esta implementación debería asegurar una distribución más equitativa de las cartas misceláneas en cada turno individual.