Carte de brassage en C #

Utilisation Shuffle de Fisher-Yates.

Votre C# code devrait ressembler à quelque chose comme ceci:

static public class FisherYates
{
    static Random r = new Random();
    // Based on Java code from wikipedia:
    // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
    static public void Shuffle(int[] deck)
    {
        for (int n = deck.Length - 1; n > 0; --n)
        {
            int k = r.Next(n+1);
            int temp = deck[n];
            deck[n] = deck[k];
            deck[k] = temp;
        }
    }
}

Je pense que c'est un cas où vous peut-être simplement se laisser emporter dans l'abstraction.

Aléatoire d'un jeu de cartes dans le logiciel est une question de fournir le pont de l'utilisateur dans un ordre aléatoire. Ce n'est pas réellement vous obliger à les mélanger à l'avance.

Init votre deck. (J'utilise généralement un nombre de 1 à 52 pour représenter la carte et mathmatically calculer la carte.)

1. Affaire d'une carte à l'aide d'un générateur de nombre aléatoire pour choisir une carte de la Pioche de cartes disponibles.
2. Échanger cette carte avec les une à la fin de la pioche.
3. Décrémenter un compteur de pointage à la fin de la présentation, pour supprimer cette carte de la pioche.
4. Passez à l'étape 1 jusqu'à ce que vous avez terminé le dessin des cartes.

Modifier: Et d'une manière générale, si vous avez un bon générateur de nombres aléatoires rien n'est gagné en "Traînant" à de multiples reprises.

Cela devrait être possible en utilisant les structures de données que vous avez indiquées. Vous avez juste besoin d'ajouter une méthode "Dessiner", et membre de la variable pour suivre la fin de la présentation. Si vous sont enfer plié sur la réalité de l'exécution de la "shuffle" à l'avance, puis Une votre professeur est un salaud, B-vous quand vous le tirage des 52 cartes du deck sont bien mélangés. Une fois que vous avez dessiner toutes les cartes, vous devez fournir un "DeckEmpty" la méthode, et la méthode pour réinitialiser la Fin de Pont pour inclure toutes les cartes à nouveau.

Votre Shuffle pourrait fonctionner, mais il n'est pas vraiment efficace et pas réaliste. Vous devriez essayer de cette façon:

//The shuffle goes like this: you take a portion of the deck, then put them in random places
private void Shuffle()
{
 int length = DeckofCards.Count;
 int level = 20; //number of shuffle iterations

 List<Card> Shuffleing; //the part of the deck were putting back
 Random rnd = new Random();
 int PickedCount, BackPortion; //the last used random number

 for (int _i = 0; _i < level; _i++)
 {
  PickedCount = rnd.Next(10, 30); //number of cards we pick out
  Shuffleing = DeckofCards.GetRange(0, PickedCount);
  DeckofCards.RemoveRange(0, PickedCount);

  while (Shuffleing.Count != 0)
  {
   PickedCount = rnd.Next(10, DeckofCards.Count - 1); //where we place a range of cards
   BackPortion = rnd.Next(1, Shuffleing.Count / 3 + 1); //the number of cards we but back in one step
   DeckofCards.InsertRange(PickedCount, Shuffleing.GetRange(0, BackPortion)); //instering a range of cards
   Shuffleing.RemoveRange(0, BackPortion); //we remove what we just placed back
  }
 }
}

De cette façon, vous pouvez obtenir un plus réalistes shuffle avec moins d'itérations

Globalement, je dirais de regarder chaque pont comme un objet qui contient un tableau d'objets de la Carte, qui chaque Carte de chaque objet contient une valeur et à la suite de l'int de la propriété, qui peut être appliqué à une énumération de valeurs et de suites pour recueillir le nom de la version que par le Type de Deck que vous utilisez. (Ce qui permettrait à ce morceau de code pour être plus polyvalent et faciliter les comparaisons de la valeur 3 < 11 (jack) !~) Votre style de travail pour un projet scolaire, je suis juste en train de trouble obsessionnel-compulsif avec elle!

class Card
{
    public int value
    { get; set; }

    public int suite
    { get; set; }
}


abstract class Deck
{
    public Card[] cards
    { get; set; }

    public void ShuffleCards(int timesToShuffle)
    {
        Card temp;
        Random random = new Random();
         //int timesToShuffle = random.Next(300, 600); #Had it setup for random shuffle
        int cardToShuffle1, cardToShuffle2; 

        for (int x = 0; x < timesToShuffle; x++)
        {
            cardToShuffle1 = random.Next(this.cards.Length);
            cardToShuffle2 = random.Next(this.cards.Length);
            temp = this.cards[cardToShuffle1];

            this.cards[cardToShuffle1] = this.cards[cardToShuffle2];
            this.cards[cardToShuffle2] = temp;
        }
    }
}

Que c'est en supposant que vous avez utilisé un Tablier de base de la classe, puis en hériter pour le type de deck que vous voulez (si vous pouvez appliquer ce même code pour Uno ponts ou ce que jamais.) Code pour le type normal de pont de classe.

class NormalDeck : Deck
{
    //This would go in the NormalGame class to apply the enumerators to the values as a cipher.
    //Need int values for logic reasons (easier to work with numbers than J or K !!!
    //Also allows for most other methods to work with other deck<Type> (ex: Uno, Go Fish, Normal cards)
    public enum Suites
    {
        Hearts,
        Diamonds,
        Spades,
        Clover
    };

    //Same comment as above. 
    public enum Values
    { Ace, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King };

    public void NewNormalDeck()
    {
        //Clear the deck of cards
        if (this.cards != null)
        {
            Array.Clear(this.cards, 0, this.cards.Length);
        }

        //Set Value to length of Normal deck of Cards without Jokers 
        cards = new Card[52];

        //to keep count of which card we are.  
        int curNumofCards = 0;

        //Cycle through all of the suites listed in "suites" then all the values of     that suite
        for (int x = 0; x < Enum.GetValues(typeof(Suites)).GetLength(0); x++)
        {
            for (int y = 0; y < Enum.GetValues(typeof(Values)).GetLength(0); y++)
            {
                Card newCard = new Card();
                newCard.suite = x;
                newCard.value = y;
                this.cards[curNumofCards] = newCard;
                curNumofCards++;
            }
        }
    }
}