Quiero que en FillWith Missellaneous no se den las cartas tan al azar, quiero que se de…
- 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; } }}
- Assistant
Para ajustar la función
FillWithMiscellaneouspara 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:
- Registro de Frecuencia de Cartas: Llevar un registro de cuántas veces se ha colocado cada carta en la sesión actual.
- 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.
- 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:
-
Registro de Frecuencia de Cartas:
timesCardPlacedse usa para mantener un registro de cuántas veces se ha colocado cada carta.
-
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.
- Ajustamos la probabilidad de selección de las cartas misceláneas usando una fórmula inversa (
-
Remoción de Cartas Pleno Uso:
- Aseguramos que una carta seleccione debido a su uso alcance su
maxCardsInPlayes removido de futuras selecciones.
- Aseguramos que una carta seleccione debido a su uso alcance su
Estos cambios deberían ayudar a distribuir las cartas de manera más equitativa y reducir la probabilidad de repetición.
- User
No, pero quiero que tomes en cuenta solo este turno, no los anteriores, timescardplaced toma en cuenta turnos anteriores
- 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
FillWithMiscellaneouspara 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:
-
Registro de Frecuencia de Cartas en el Turno:
- Se ha añadido un diccionario
cardsInThisTurnpara rastrear cuántas veces se ha colocado cada carta dentro del turno actual.
- Se ha añadido un diccionario
-
Ajuste de Probabilidades en
FillWithMiscellaneous:- Las probabilidades de seleccionar cartas se ajustan dinámicamente durante el turno actual usando
1 / (1 + placedInThisTurn).
- Las probabilidades de seleccionar cartas se ajustan dinámicamente durante el turno actual usando
-
Actualización de
currentCardsInPlay:- Se incrementa
currentCardsInPlayy se elimina la carta de la lista si se alcanza el máximo permitido en el turno actual.
- Se incrementa
Esta implementación debería asegurar una distribución más equitativa de las cartas misceláneas en cada turno individual.
-