Trying to Shuffle the colored cards. Code is not working. Do you know what I am doing wrong?

Questions & Answers
1

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

public class ColorSorter : MonoBehaviour
{
public static string colors = {“r”, “b”, “p”, “o”};
public static string values = {“1”, “2”, “3”, “4”, “5”};

public List<string> deck;

public GameObject RedSquare1, RedSquare2, RedSquare3, RedSquare4, RedSquare5, BlueSquare1, BlueSquare2, BlueSquare3, BlueSquare4, BlueSquare5, OrangeSquare1, OrangeSquare2, OrangeSquare3, OrangeSquare4, OrangeSquare5, PurpleSquare1, PurpleSquare2, PurpleSquare3, PurpleSquare4, PurpleSquare5, Red, Purple, Blue, Orange;

Vector2 RedSquare1InitialPos, RedSquare2InitialPos, RedSquare3InitialPos, RedSquare4InitialPos, RedSquare5InitialPos, BlueSquare1InitialPos, BlueSquare2InitialPos, BlueSquare3InitialPos, BlueSquare4InitialPos, BlueSquare5InitialPos, OrangeSquare1InitialPos, OrangeSquare2InitialPos, OrangeSquare3InitialPos, OrangeSquare4InitialPos, OrangeSquare5InitialPos, PurpleSquare1InitialPos, PurpleSquare2InitialPos, PurpleSquare3InitialPos, PurpleSquare4InitialPos, PurpleSquare5InitialPos;

void Start()
{
    PlayCards();
    RedSquare1InitialPos = RedSquare1.transform.position;
    RedSquare2InitialPos = RedSquare2.transform.position;
    RedSquare3InitialPos = RedSquare3.transform.position;
    RedSquare4InitialPos = RedSquare4.transform.position;
    RedSquare5InitialPos = RedSquare5.transform.position;
    BlueSquare1InitialPos = BlueSquare1.transform.position;
    BlueSquare2InitialPos = BlueSquare2.transform.position;
    BlueSquare3InitialPos = BlueSquare3.transform.position;
    BlueSquare4InitialPos = BlueSquare4.transform.position;
    BlueSquare5InitialPos = BlueSquare5.transform.position;
    OrangeSquare1InitialPos = OrangeSquare1.transform.position;
    OrangeSquare2InitialPos = OrangeSquare2.transform.position;
    OrangeSquare3InitialPos = OrangeSquare3.transform.position;
    OrangeSquare4InitialPos = OrangeSquare4.transform.position;
    OrangeSquare5InitialPos = OrangeSquare5.transform.position;
    PurpleSquare1InitialPos = PurpleSquare1.transform.position;
    PurpleSquare2InitialPos = PurpleSquare2.transform.position;
    PurpleSquare3InitialPos = PurpleSquare3.transform.position;
    PurpleSquare4InitialPos = PurpleSquare4.transform.position;
    PurpleSquare5InitialPos = PurpleSquare5.transform.position;
}

public void DragRedSquare1()
{
    RedSquare1.transform.position = Input.mousePosition;
}

public void DragRedSquare2()
{
    RedSquare2.transform.position = Input.mousePosition;
}

public void DragRedSquare3()
{
    RedSquare3.transform.position = Input.mousePosition;
}

public void DragRedSquare4()
{
    RedSquare4.transform.position = Input.mousePosition;
}

public void DragRedSquare5()
{
    RedSquare5.transform.position = Input.mousePosition;
}

public void DragBlueSquare1()
{
    BlueSquare1.transform.position = Input.mousePosition;
}

public void DragBlueSquare2()
{
    BlueSquare2.transform.position = Input.mousePosition;
}

public void DragBlueSquare3()
{
    BlueSquare3.transform.position = Input.mousePosition;
}

public void DragBlueSquare4()
{
    BlueSquare4.transform.position = Input.mousePosition;
}

public void DragBlueSquare5()
{
    BlueSquare5.transform.position = Input.mousePosition;
}

public void DragOrangeSquare1()
{
    OrangeSquare1.transform.position = Input.mousePosition;
}

public void DragOrangeSquare2()
{
    OrangeSquare2.transform.position = Input.mousePosition;
}

public void DragOrangeSquare3()
{
    OrangeSquare3.transform.position = Input.mousePosition;
}

public void DragOrangeSquare4()
{
    OrangeSquare4.transform.position = Input.mousePosition;
}

public void DragOrangeSquare5()
{
    OrangeSquare5.transform.position = Input.mousePosition;
}

public void DragPurpleSquare1()
{
    PurpleSquare1.transform.position = Input.mousePosition;
}

public void DragPurpleSquare2()
{
    PurpleSquare2.transform.position = Input.mousePosition;
}

public void DragPurpleSquare3()
{
    PurpleSquare3.transform.position = Input.mousePosition;
}

public void DragPurpleSquare4()
{
    PurpleSquare4.transform.position = Input.mousePosition;
}

public void DragPurpleSquare5()
{
    PurpleSquare5.transform.position = Input.mousePosition;
}

public void DropRedSquare1()
{
    float Distance = Vector3.Distance(RedSquare1.transform.position, Red.transform.position);
    if(Distance < 400)
    {
        RedSquare1.transform.position = Red.transform.position;
    }
    else
    {
        RedSquare1.transform.position = RedSquare1InitialPos;
    }
}

 public void DropRedSquare2()
{
    float Distance = Vector3.Distance(RedSquare2.transform.position, Red.transform.position);
    if(Distance < 400)
    {
        RedSquare2.transform.position = Red.transform.position;
    }
    else
    {
        RedSquare2.transform.position = RedSquare2InitialPos;
    }
}

 public void DropRedSquare3()
{
    float Distance = Vector3.Distance(RedSquare3.transform.position, Red.transform.position);
    if(Distance < 400)
    {
        RedSquare3.transform.position = Red.transform.position;
    }
    else
    {
        RedSquare3.transform.position = RedSquare3InitialPos;
    }
}

 public void DropRedSquare4()
{
    float Distance = Vector3.Distance(RedSquare4.transform.position, Red.transform.position);
    if(Distance < 400)
    {
        RedSquare4.transform.position = Red.transform.position;
    }
    else
    {
        RedSquare4.transform.position = RedSquare4InitialPos;
    }
}

 public void DropRedSquare5()
{
    float Distance = Vector3.Distance(RedSquare5.transform.position, Red.transform.position);
    if(Distance < 400)
    {
        RedSquare5.transform.position = Red.transform.position;
    }
    else
    {
        RedSquare5.transform.position = RedSquare5InitialPos;
    }
}

    public void DropBlueSquare1()
{
    float Distance = Vector3.Distance(BlueSquare1.transform.position, Blue.transform.position);
    if(Distance < 400)
    {
        BlueSquare1.transform.position = Blue.transform.position;
    }
    else
    {
        BlueSquare1.transform.position = BlueSquare1InitialPos;
    }
}

 public void DropBlueSquare2()
{
    float Distance = Vector3.Distance(BlueSquare2.transform.position, Blue.transform.position);
    if(Distance < 400)
    {
        BlueSquare2.transform.position = Blue.transform.position;
    }
    else
    {
        BlueSquare2.transform.position = BlueSquare2InitialPos;
    }
}

 public void DropBlueSquare3()
{
    float Distance = Vector3.Distance(BlueSquare3.transform.position, Blue.transform.position);
    if(Distance < 400)
    {
        BlueSquare3.transform.position = Blue.transform.position;
    }
    else
    {
        BlueSquare3.transform.position = BlueSquare3InitialPos;
    }
}

 public void DropBlueSquare4()
{
    float Distance = Vector3.Distance(BlueSquare4.transform.position, Blue.transform.position);
    if(Distance < 400)
    {
        BlueSquare4.transform.position = Blue.transform.position;
    }
    else
    {
        BlueSquare4.transform.position = BlueSquare4InitialPos;
    }
}

 public void DropBlueSquare5()
{
    float Distance = Vector3.Distance(BlueSquare5.transform.position, Blue.transform.position);
    if(Distance < 400)
    {
        BlueSquare5.transform.position = Blue.transform.position;
    }
    else
    {
        BlueSquare5.transform.position = BlueSquare5InitialPos;
    }
}

    public void DropOrangeSquare1()
{
    float Distance = Vector3.Distance(OrangeSquare1.transform.position, Orange.transform.position);
    if(Distance < 400)
    {
        OrangeSquare1.transform.position = Orange.transform.position;
    }
    else
    {
        OrangeSquare1.transform.position = OrangeSquare1InitialPos;
    }
}

 public void DropOrangeSquare2()
{
    float Distance = Vector3.Distance(OrangeSquare2.transform.position, Orange.transform.position);
    if(Distance < 400)
    {
        OrangeSquare2.transform.position = Orange.transform.position;
    }
    else
    {
        OrangeSquare2.transform.position = OrangeSquare2InitialPos;
    }
}

 public void DropOrangeSquare3()
{
    float Distance = Vector3.Distance(OrangeSquare3.transform.position, Orange.transform.position);
    if(Distance < 400)
    {
        OrangeSquare3.transform.position = Orange.transform.position;
    }
    else
    {
        OrangeSquare3.transform.position = OrangeSquare3InitialPos;
    }
}

 public void DropOrangeSquare4()
{
    float Distance = Vector3.Distance(OrangeSquare4.transform.position, Orange.transform.position);
    if(Distance < 400)
    {
        OrangeSquare4.transform.position = Orange.transform.position;
    }
    else
    {
        OrangeSquare4.transform.position = OrangeSquare4InitialPos;
    }
}

 public void DropOrangeSquare5()
{
    float Distance = Vector3.Distance(OrangeSquare5.transform.position, Orange.transform.position);
    if(Distance < 400)
    {
        OrangeSquare5.transform.position = Orange.transform.position;
    }
    else
    {
        OrangeSquare5.transform.position = OrangeSquare5InitialPos;
    }
}

    public void DropPurpleSquare1()
{
    float Distance = Vector3.Distance(PurpleSquare1.transform.position, Purple.transform.position);
    if(Distance < 400)
    {
        PurpleSquare1.transform.position = Purple.transform.position;
    }
    else
    {
        PurpleSquare1.transform.position = PurpleSquare1InitialPos;
    }
}

 public void DropPurpleSquare2()
{
    float Distance = Vector3.Distance(PurpleSquare2.transform.position, Purple.transform.position);
    if(Distance < 400)
    {
        PurpleSquare2.transform.position = Purple.transform.position;
    }
    else
    {
        PurpleSquare2.transform.position = PurpleSquare2InitialPos;
    }
}

 public void DropPurpleSquare3()
{
    float Distance = Vector3.Distance(PurpleSquare3.transform.position, Purple.transform.position);
    if(Distance < 400)
    {
        PurpleSquare3.transform.position = Purple.transform.position;
    }
    else
    {
        PurpleSquare3.transform.position = PurpleSquare3InitialPos;
    }
}

 public void DropPurpleSquare4()
{
    float Distance = Vector3.Distance(PurpleSquare4.transform.position, Purple.transform.position);
    if(Distance < 400)
    {
        PurpleSquare4.transform.position = Purple.transform.position;
    }
    else
    {
        PurpleSquare4.transform.position = PurpleSquare4InitialPos;
    }
}

 public void DropPurpleSquare5()
{
    float Distance = Vector3.Distance(PurpleSquare5.transform.position, Purple.transform.position);
    if(Distance < 400)
    {
        PurpleSquare5.transform.position = Purple.transform.position;
    }
    else
    {
        PurpleSquare5.transform.position = PurpleSquare5InitialPos;
    }
}

 public void PlayCards()
{
    deck = GenerateDeck();
    Shuffle(deck);

    //test the cards in the deck
   // foreach (string card in deck)
   // {
   //     print(card);
   // }

}

public static List<string> GenerateDeck()
{
    List<string> newDeck = new List<string>();
    foreach (string c in colors)
    {
        foreach (string v in values)
     {
        newDeck.Add(c + v);
     }
    }
    return newDeck;
}

    void Shuffle<T>(List<T> list)
{
    System.Random random = new System.Random();
    int n = list.Count;
    while (n > 1)
    {
        int k = random.Next(n);
        n--;
        T temp = list[k];
        list[k] = list[n];
        list[n] = temp;
    }
}

}

2

If you pass the list “deck” to your Shuffle method, it shuffles copy of your deck. Not the original. To shuffle the original deck, you have to pass it with ref parameter. So, modify your script as follows.

Change this line:

Shuffle(deck);

like that:

Shuffle(ref deck);

next, look at this line:

void Shuffle<T>(List<T> list)

and change it like that:

void Shuffle<T>(ref List<T> list)
3

In your Shuffle method, there’s something going on with the index in the while loop. You can try something like:

 void Shuffle<T>(ref List<T> list)
    {
        System.Random random = new System.Random();
        int n = list.Count;
        while (n > 1)
        {
            n--;
            int k = random.Next(n+1);
            T temp = list[k];
            list[k] = list[n];
            list[n] = temp;
        }
    }

On the other hand, the rest of the code can be wildly optimized and I encourage you to try to do so. Here is one possible simplification:

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

public class SquareData
{
    public TeamColor team = TeamColor.Red;
    public Vector3 initialPosition;
}

public enum TeamColor { Red, Purple, Blue, Orange }

public class ColorSorter : MonoBehaviour
{
    public static string[] colors = { "r", "b", "p", "o" };
    public static string[] values = { "1", "2", "3", "4", "5" };

    public List<string> deck;

    public GameObject Red, Purple, Blue, Orange;

    public GameObject[] RedSquares = new GameObject[5];
    public GameObject[] BlueSquares = new GameObject[5];
    public GameObject[] PurpleSquares = new GameObject[5];
    public GameObject[] OrangeSquares = new GameObject[5];


    void Start()
    {
        PlayCards();
        InitializeSquares(RedSquares);
        InitializeSquares(BlueSquares);
        InitializeSquares(PurpleSquares);
        InitializeSquares(OrangeSquares);
    }

    void InitializeSquares(GameObject[] teamSquares)
    {
        foreach (var square in teamSquares)
        {
            SquareData data = square.GetComponent<SquareData>();
            if (data != null)
                data.initialPosition = square.transform.position;
        }
    }

    public void DragSquare(GameObject square)
    {
        square.transform.position = Input.mousePosition;
    }

    public void DropRedSquare(GameObject square, GameObject team)
    {
        SquareData data = square.GetComponent<SquareData>();
        Vector3 squarePosition = square.transform.position;
        Vector3 teamPosition;

        switch (data.team)
        {
            case TeamColor.Red:
                teamPosition = Red.transform.position;
                break;
            case TeamColor.Purple:
                teamPosition = Purple.transform.position;
                break;
            case TeamColor.Blue:
                teamPosition = Blue.transform.position;
                break;
            case TeamColor.Orange:
                teamPosition = Orange.transform.position;
                break;
            default:
                teamPosition = Red.transform.position;
                break;
        }

        float Distance = Vector3.Distance(squarePosition, teamPosition);
        if (Distance < 400)
        {
            square.transform.position = teamPosition;
        }
        else
        {
            square.transform.position = data.initialPosition;
        }
    }

    public void PlayCards()
    {
        deck = GenerateDeck();
        Shuffle(ref deck);
        //test the cards in the deck
        // foreach (string card in deck)
        // {
        //     print(card);
        // }
    }

    public static List<string> GenerateDeck()
    {
        List<string> newDeck = new List<string>();
        foreach (string c in colors)
        {
            foreach (string v in values)
            {
                newDeck.Add(c + v);
            }
        }
        return newDeck;
    }

    void Shuffle<T>(ref List<T> list)
    {
        System.Random random = new System.Random();
        int n = list.Count;
        while (n > 1)
        {
            n--;
            int k = random.Next(n + 1);
            T temp = list[k];
            list[k] = list[n];
            list[n] = temp;
        }
    }
}

Notice how I created a custom SquareData class that holds the team it belongs to and its initial position. Also, stored all squares in arrays so their management is way more friendly.
I haven’t changed the GenerateDeck method because I’m not sure what are you trying to accomplish with it.

Keep it up! :slight_smile: