10.2c — Decks: Shuffle, Draw & Traverse

Compare against your own file rather than copying it. Three things have to match and nothing else does: both Shuffle overloads are filled in, the random pick is UnityEngine.Random.Range(0, i + 1) with the max-exclusive + 1 and the qualified class name, and Draw reads deck[0] before it removes it, behind the empty-deck guard. Your parameter names, your spacing constant, your deck size and everything Deal() does after the two draws are yours. The gap line is the one that carries the whole lesson: it is the only place the AP pseudocode and C# genuinely disagree, in three ways at once.

// ------------------------------------------------------------------
//  REFERENCE FILE — Assets/Scripts/GameManager.cs
//  Written to be read, not pasted. Build it with the walkthrough
//  above, one step at a time, then open this and compare.
//  If it is sitting in your project unchanged, that is the thing
//  to go and do now — the walkthrough is still above you.
// ------------------------------------------------------------------
using System.Collections;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    public static GameManager gm;

    // The decks are Card_data (the 10.2b assets); the hands and the piles are
    // Card (the components on screen). Two element types, so two Shuffle overloads.
    public List<Card_data> player_deck = new List<Card_data>();
    public List<Card_data> ai_deck = new List<Card_data>();
    public List<Card> player_hand = new List<Card>();
    public List<Card> ai_hand = new List<Card>();
    public List<Card> player_discard_pile = new List<Card>();
    public List<Card> ai_discard_pile = new List<Card>();

    public Canvas canvas;
    public GameObject blank_card;
    public Vector3 player_hand_location;
    public Vector3 ai_hand_location;

    private void Awake()
    {
        if (gm != null && gm != this)
        {
            Destroy(gameObject);
        }
        else
        {
            gm = this;
            DontDestroyOnLoad(this.gameObject);
        }
    }

    void Start()
    {
        canvas = FindAnyObjectByType<Canvas>();
        ai_hand_location = player_hand_location + new Vector3(0, 350, 0);

        Deal();
    }

    void Deal()
    {
        // Shuffle both decks BEFORE anything is drawn: Draw takes deck[0],
        // so whoever the shuffle left on top is who gets dealt.
        Shuffle(player_deck);
        Shuffle(ai_deck);

        Draw(player_deck, player_hand, player_hand_location);
        Draw(ai_deck, ai_hand, ai_hand_location);

        // The starter's own line, now reading the hand Draw just filled.
        player_hand[0].GetComponent<DraggableUI>().enabled = false;
    }

    // Fisher-Yates, overload (a) — the decks. Walk from the end; at each slot
    // pick a random earlier-or-equal slot; swap through a temp.
    // AP: FOR i FROM LENGTH TO 2 / r <- RANDOM(1, i) / SWAP(list[i], list[r])
    void Shuffle(List<Card_data> data_hand)
    {
        for (int i = data_hand.Count - 1; i > 0; i--)
        {
            // Range is MAX-EXCLUSIVE for ints, so i + 1 makes the range 0..i —
            // and UnityEngine. is required: Unity.Mathematics.Random is also
            // in scope in this file (see the Concept Lab callout on the ambiguity).
            int r = UnityEngine.Random.Range(0, i + 1);

            Card_data temp = data_hand[i];
            data_hand[i] = data_hand[r];
            data_hand[r] = temp;
        }
    }

    // The same six lines, for the hands and piles. Copy, do not guess: an empty
    // body here is a silent no-op, and nothing in C# will warn you about it.
    void Shuffle(List<Card> card_hand)
    {
        for (int i = card_hand.Count - 1; i > 0; i--)
        {
            int r = UnityEngine.Random.Range(0, i + 1);

            Card temp = card_hand[i];
            card_hand[i] = card_hand[r];
            card_hand[r] = temp;
        }
    }

    // Move the top of a deck into a hand, and put it on screen while you do it.
    void Draw(List<Card_data> deck, List<Card> hand, Vector3 where)
    {
        // The boundary: deck[0] on an empty list is a crash, not a null.
        if (deck.Count == 0) return;

        GameObject new_card = Instantiate(blank_card, where, Quaternion.identity, canvas.transform);

        // Read the top FIRST — RemoveAt(0) below would shift a different card
        // into index 0.
        new_card.GetComponent<Card>().data = deck[0];
        hand.Add(new_card.GetComponent<Card>());
        deck.RemoveAt(0);
    }

    // Position IS the index: the hand spreads because of a loop counter.
    // This one cannot be a foreach — a foreach has no i.
    void LayoutHand(List<Card> hand, Vector3 origin)
    {
        for (int i = 0; i < hand.Count; i++)
        {
            hand[i].transform.position = origin + new Vector3(i * 160f, 0f, 0f);
        }
    }

    void AI_Turn()
    {
        // The next lesson's problem.
    }
}

// The two loops side by side, for reference:
//
//   index loop  — you NEED i for positions:
//     for (int i = 0; i < hand.Count; i++) { Layout(hand[i], i); }
//
//   foreach     — you only need each card:
//     int total = 0;
//     foreach (Card c in hand) { total += c.data.cost; }