Selection of scripts forming the core of interacting with the cards in your hand

CardSlotHolder.cs

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

public class CardSlotHolder : MonoBehaviour {
    public enum SlotType { EMPTY, GENERIC, GRABBAG};

    public SlotType typeOfSlot;
    public bool shouldSpawnCard = true;

    public SingleCard cardHeld;
    //Add reference to enemy
    public CardSlotManager manager;
    public bool isAdditionType;

    public GameObject GenericToSpawn;

    int difficulty = 0;
    private void Start() {
        difficulty = Random.Range(1, 3);
    }

    private void Update() {
        if(typeOfSlot == SlotType.GENERIC && shouldSpawnCard && cardHeld == null) {
            shouldSpawnCard = false;
            StartCoroutine(ReloadCard());
        }
    }

    IEnumerator ReloadCard() {
        for (int i = 0; i < 3; i++) {
            yield return new WaitForFixedUpdate();
        }

        if (!isAdditionType && !manager.isGraveyard) {
            GetComponent<BoxCollider>().enabled = false;
            GenericToSpawn.GetComponent<SingleCard>().cardValue = difficulty;
            GameObject generalMinusCard = Instantiate(GenericToSpawn, transform.position, Quaternion.identity, transform);
            generalMinusCard.GetComponent<DragTransform>().SlotIn(transform);
            shouldSpawnCard = true;
        }
    }
    
    public void GrabCardsFromBag() {
        StartCoroutine(LoadGrabBagCard());
    }

    IEnumerator LoadGrabBagCard() {
        for (int i = 0; i < 3; i++) {
            yield return new WaitForFixedUpdate();
        }

        SingleCard cardFromGrabBag = manager.GetDeckManager().GetGrabBagCard();
        GameObject generalMinusCard = Instantiate(GenericToSpawn, transform.position, Quaternion.identity, transform);
        generalMinusCard.GetComponent<SingleCard>().SetValues(cardFromGrabBag, generalMinusCard, this);
        generalMinusCard.GetComponent<SingleCard>().isGrabBagCard = true;
        generalMinusCard.GetComponent<DragTransform>().SlotIn(transform);
        generalMinusCard.GetComponent<BoxCollider2D>().enabled = true;
    }

    public void SetCard(GameObject newCard) {
        SingleCard tempCard = newCard.GetComponent<SingleCard>();
        if (cardHeld != null) {
            if(tempCard != cardHeld) {
                cardHeld.GetComponent<DragTransform>().Expunge();
            }
        }
        cardHeld = tempCard;

        if(manager)
            manager.SlotUpdated(gameObject);
        //Tell the enemy reference to check if all cards are filled
    }
}

CardSlotManager.cs

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

public class CardSlotManager : MonoBehaviour {
    public bool isGraveyard = false;

    [Tooltip("+, -")]
    public GameObject[] slotTypes;
    [Tooltip("+, -")]
    public GameObject[] symbolTypes;
    public List<GameObject> equation;

    public AnimationCurve customCombineLerp;
    public AnimationCurve attackAnimCurve;
    public AnimationCurve healAnimCurve;
    public AnimationCurve slowAnimCurve;
    public AnimationCurve rotateAnimCurve;
    public GameObject flash;
    public GameObject freshNewCard;

    public PlayerHealthBar PHB;

    Deck deckManager;
    AudioSource SFXbox;

    [Tooltip("Diamond, Heart, Spade, Club")]
    public AudioClip[] effectSounds;
    // Start is called before the first frame update
    void Start() {
        SFXbox = GetComponent<AudioSource>();
        deckManager = FindObjectOfType<Deck>();

        for (int i = 0; i < equation.Count; i += 2) {
            CardSlotHolder currentHolder = equation[i].GetComponent<CardSlotHolder>();
            if (currentHolder) {
                currentHolder.manager = this;
            }
        }
    }

    public bool debugTesting = false;
    private void Update() {
        if (debugTesting) {
            debugTesting = false;
            GenerateSlots(true);
        }
    }

    //Generate Slots Randomly
    public void GenerateSlots() {
        GenerateSlots(-1, -1);
    }
    //numSlotsToMake is -1, choose randomly
    //isSubtraction: 0 == false, 1 == true, -1 == random
    public void GenerateSlots(int numSlotsToMake, int isSubtraction) {
        if (equation.Count > 0) {
            foreach (GameObject go in equation) {
                Destroy(go);
            }
        }
        equation.Clear();

        //Choose randomly
        if (numSlotsToMake == -1) {
            numSlotsToMake = Random.Range(1, 3);
        }

        GameObject initialSlot = Instantiate(slotTypes[0], transform);
        equation.Add(initialSlot);
        initialSlot.GetComponent<CardSlotHolder>().manager = this;

        //Creates the slots
        for (int i = 1; i < numSlotsToMake; i++) {
            if (isSubtraction == -1) {
                isSubtraction = Random.Range(0, 2);
            }
            GameObject tempCardSlot = Instantiate(slotTypes[isSubtraction], transform);
            tempCardSlot.GetComponent<CardSlotHolder>().manager = this;
            equation.Add(tempCardSlot);
        }
        //Adds the symbols between each slot
        for (int index = 1; index < equation.Count; index++) {
            for (int type = 0; type < slotTypes.Length; type++) {
                if (equation[index].GetComponent<CardSlotHolder>().isAdditionType == slotTypes[type].GetComponent<CardSlotHolder>().isAdditionType) {
                    GameObject tempSymbol = Instantiate(symbolTypes[type], transform);
                    equation.Insert(index, tempSymbol);
                    index++;
                    break;
                }
            }
        }

        //Sets every object to the correct distances

        int indexCenter = equation.Count / 2;

        for (int i = 0; i < equation.Count; i++) {
            equation[i].transform.localPosition = new Vector3(2 * (i - indexCenter), 0, 1);
        }

    }
    /// <summary>
    /// Generates Card Slots for an enemy that is actually the shopkeeper
    /// </summary>
    /// <param name="isShopGenertaion"></param>
    public void GenerateSlots(bool isShopGenertaion) {
        if (equation.Count > 0) {
            foreach (GameObject go in equation) {
                Destroy(go);
            }
        }
        equation.Clear();

        //Choose randomly
        int numSlotsToMake = 3;

        GameObject initialSlot = Instantiate(slotTypes[2], transform);
        equation.Add(initialSlot);
        initialSlot.GetComponent<CardSlotHolder>().manager = this;

        //Creates the slots
        for (int i = 1; i < numSlotsToMake; i++) {
            GameObject tempCardSlot = Instantiate(slotTypes[0], transform);
            tempCardSlot.GetComponent<CardSlotHolder>().manager = this;
            equation.Add(tempCardSlot);
        }
        //Sets every object to the correct distances

        int indexCenter = equation.Count / 2;
        
        for (int i = 0; i < equation.Count; i++) {
            equation[i].transform.localPosition = new Vector3(2 * (i - indexCenter), 0, 1);
            equation[i].GetComponent<CardSlotHolder>().GrabCardsFromBag();
        }

        FindObjectOfType<ShoppingCart>().ShoppingTime();
    }


    public Deck GetDeckManager() { return deckManager; }

    public void SlotUpdated(GameObject CSH) {
        for(int i =0; i < equation.Count; i+= 2) {
            if(equation[i] == CSH) {
                continue;
            }
            else if(CSH.GetComponent<CardSlotHolder>().cardHeld == equation[i].GetComponent<CardSlotHolder>().cardHeld ) {
                equation[i].GetComponent<CardSlotHolder>().cardHeld = null;
            }
        }

        if (CheckIfFull()) {
            //
            //Do math
            //
            int totalValue = equation[0].GetComponent<CardSlotHolder>().cardHeld.cardValue;
            CardDisplay.Suit currentSuit = equation[0].GetComponent<CardSlotHolder>().cardHeld.cardSuit;
            for (int i = 1; i < equation.Count; i += 2) {
                if (equation[i].tag == symbolTypes[0].tag) {
                    totalValue += equation[i + 1].GetComponent<CardSlotHolder>().cardHeld.cardValue;
                }
                else {
                    totalValue -= equation[i + 1].GetComponent<CardSlotHolder>().cardHeld.cardValue;
                }
            }

            for(int i = 0; i < equation.Count; i++) {
                if(equation[i].tag != symbolTypes[0].tag && equation[i].tag != symbolTypes[1].tag) {
                    equation[i].GetComponent<CardSlotHolder>().cardHeld.GetComponent<BoxCollider2D>().enabled = false;
                }
            }

            if(totalValue >= 10) {
                totalValue = 10;
            }

            StartCoroutine(CombineCards(totalValue, currentSuit));
        }
    }

    float timeToPushCardsTogether = 0.5f;
    IEnumerator CombineCards(int value, CardDisplay.Suit suit) {
        float timeSinceStart = 0f;

        SingleCard firstCard = equation[0].GetComponent<CardSlotHolder>().cardHeld;

        //Move cards together
        if (equation.Count > 2) {
            while (timeSinceStart < timeToPushCardsTogether) {
                yield return null;
                timeSinceStart += Time.deltaTime;

                for (int i = 0; i < equation.Count; i += 2) {
                    Transform currentTrans = equation[i].GetComponent<CardSlotHolder>().cardHeld.transform;

                    currentTrans.position = Vector2.Lerp(equation[i].transform.position, equation[1].transform.position, customCombineLerp.Evaluate(timeSinceStart / timeToPushCardsTogether));
                }
            }
        }

        //When they get close, make a white circle that overtakes the cards
        //The circle "flashes" (lerps big and then small)
        GameObject combineFlash;
        if (equation.Count > 2) {
            combineFlash = Instantiate(flash, equation[1].transform.position, Quaternion.identity);
        }
        else {
            combineFlash = Instantiate(flash, equation[0].transform.position, Quaternion.identity);
        }
        combineFlash.transform.localScale = new Vector3(0, 0, 0);
        timeSinceStart = 0;
        float timeToExpand = 0.2f;

        while (timeSinceStart < timeToExpand) {
            yield return null;
            timeSinceStart += Time.deltaTime;

            combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand));
        }

        GameObject cardToAnimate = null;
        //
        //Instantiate the new card
        if (!isGraveyard) {
            GameObject newCard = Instantiate(freshNewCard, equation[equation.Count / 2].transform.position, Quaternion.identity);
            newCard.transform.localScale = equation[0].transform.localScale;
            SingleCard tempCard = new SingleCard(value, (int)suit);
            newCard.GetComponent<SingleCard>().SetValues(tempCard, newCard);
            yield return new WaitForFixedUpdate();
            newCard.GetComponent<SingleCard>().SetSortingValue(5, true);
            newCard.GetComponent<BoxCollider2D>().enabled = false;
            cardToAnimate = newCard;

            if(equation.Count > 2) {
                deckManager.AddGrabBagCard(tempCard);
            }

            Destroy(newCard, timeSinceStart + 2f);
        }

        //
        //Delete the other cards
        for (int i = 0; i < equation.Count; i += 2) {
            deckManager.CardPlayed(equation[i].GetComponent<CardSlotHolder>().cardHeld);
        }

        //
        //Make flash effect go away
        while (timeSinceStart > 0) {
            yield return null;
            timeSinceStart -= Time.deltaTime;

            combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand));
        }

        Destroy(combineFlash);

        //
        //Effect takes place
        //
        if (!isGraveyard) {
            Vector3 initPos = cardToAnimate.transform.position;
            Vector3 initScale = cardToAnimate.transform.localScale;
            Vector3 targetPos;
            timeSinceStart = 0f;

            //
            //Blank Card
            if (value <= 0) {
                timeSinceStart = 0f;
                combineFlash = Instantiate(flash, cardToAnimate.transform.position, Quaternion.identity);
                combineFlash.transform.localScale = new Vector3(0, 0, 0);
                while (timeSinceStart < timeToExpand) {
                    yield return null;
                    timeSinceStart += Time.deltaTime;

                    combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand));
                }
                //Delete the blank cards
                Destroy(cardToAnimate);

                //Make flash effect go away
                while (timeSinceStart > 0) {
                    yield return null;
                    timeSinceStart -= Time.deltaTime;

                    combineFlash.transform.localScale = Vector3.Lerp(new Vector3(0, 0, 0), new Vector3(4, 4, 4), customCombineLerp.Evaluate(timeSinceStart / timeToExpand));
                }

                int numCardsToDraw = equation.Count / 2 + 1;
                for (int i = 0; i < equation.Count; i++) {
                    if(equation[i].tag == "-" && equation[i+1].GetComponent<CardSlotHolder>().shouldSpawnCard) {
                        numCardsToDraw--;
                    }
                }

                for (int i = 0; i < numCardsToDraw; i++) {
                    deckManager.DrawCard();
                }
                yield break;
            }

            //
            //Diamonds Hurt Red Enemies
            //
            if (suit == CardDisplay.Suit.DIAMOND) {
                StartCoroutine(AttackAnimation(cardToAnimate, true));
            }
            //
            //Spades Hurt Black Enemies
            //
            else if (suit == CardDisplay.Suit.SPADE) {
                StartCoroutine(AttackAnimation(cardToAnimate, false));
            }
            //
            //Hearts Heal the player
            //
            else if (suit == CardDisplay.Suit.HEART) {
                targetPos = initPos;
                targetPos.y = -10;

                Vector3 tempVector = new Vector3(0, 0, 0);
                Vector3 travelVector = targetPos - initPos;

                PHB.HealDamage(value);
                while (timeSinceStart < 1.5f) {
                    yield return null;
                    timeSinceStart += Time.deltaTime;
                    tempVector = healAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector;
                    cardToAnimate.transform.position = initPos + tempVector;
                    cardToAnimate.transform.localScale = new Vector3(rotateAnimCurve.Evaluate(timeSinceStart / 1.5f) * initScale.x,
                        initScale.y, initScale.z);
                }
            }
            //
            //Clubs slow the enemy
            //
            else if (suit == CardDisplay.Suit.CLUB) {
                targetPos = initPos;
                targetPos.y = 6;

                Vector3 tempVector = new Vector3(0, 0, 0);
                Vector3 travelVector = targetPos - initPos;


                EnemySpawner.instance.currentEnemy.GetComponent<Enemy>().SlowEffect(value);
                while (timeSinceStart < 1.5f) {
                    yield return null;
                    timeSinceStart += Time.deltaTime;
                    tempVector = healAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector;
                    cardToAnimate.transform.position = initPos + tempVector;
                    cardToAnimate.transform.localScale = new Vector3(rotateAnimCurve.Evaluate(timeSinceStart / 1.5f) * initScale.x,
                        initScale.y, initScale.z);
                }
            }
        }
        else {
            deckManager.StopAllCoroutines();
            deckManager.DrawCard();
        }
    }

    IEnumerator AttackAnimation(GameObject cardToAnimate, bool isDiamondAttack) {
        float timeSinceStart = 0f;
        Vector3 initPos = cardToAnimate.transform.position;
        Vector3 targetPos;
        int value = cardToAnimate.GetComponent<SingleCard>().cardValue;

        targetPos = initPos;
        targetPos.y = 6;

        Vector3 tempVector = new Vector3(0, 0, 0);
        Vector3 travelVector = targetPos - initPos;

        if (EnemySpawner.instance.currentEnemy == null) {
            yield break;
        }
        Enemy enemyScript = EnemySpawner.instance.currentEnemy.GetComponent<Enemy>();
        enemyScript.GetHit(value, isDiamondAttack);

        if (isDiamondAttack && enemyScript.isRed
            || !isDiamondAttack && !enemyScript.isRed) {
            SFXbox.clip = effectSounds[2];
            SFXbox.Play();
            while (timeSinceStart < 1.5f) {
                yield return null;
                timeSinceStart += Time.deltaTime;
                tempVector = attackAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector;
                cardToAnimate.transform.position = initPos + tempVector;
            }
        }
        else {
            SFXbox.clip = effectSounds[1];
            SFXbox.Play();

            float deflectAmount = Random.Range(30f, 70f);
            //Debug.Log(deflectAmount);
            deflectAmount *= (Random.Range(0, 2) % 2 == 0) ? 1 : -1;
            float startX = cardToAnimate.transform.position.x;
            float deflectStartTime = 0f;

            while (timeSinceStart < 1.5f) {
                yield return null;
                timeSinceStart += Time.deltaTime;
                tempVector = attackAnimCurve.Evaluate(timeSinceStart / 2f) * travelVector;
                if (cardToAnimate.transform.position.y >= 1) {
                    if (deflectStartTime < 0.01) {
                        deflectStartTime = timeSinceStart;
                        //Play sound
                        SFXbox.clip = effectSounds[0];
                        SFXbox.Play();
                    }
                    float newXPos = Mathf.Lerp(startX, startX + deflectAmount,
                        (timeSinceStart - deflectStartTime) / (1.15f - deflectStartTime));
                    tempVector.x = newXPos;
                }

                cardToAnimate.transform.position = initPos + tempVector;
            }
            //Debug.Log(cardToAnimate.transform.position);
        }
    }


    public bool CheckIfFull() {
        for (int i = 0; i < equation.Count; i += 2) {
            CardSlotHolder currentSlot = equation[i].GetComponent<CardSlotHolder>();
            if (currentSlot.cardHeld == null) {
                return false;
            }
            if(currentSlot.typeOfSlot == CardSlotHolder.SlotType.GRABBAG) {
                return false;
            }
        }
        return true;
    }
}

Deck.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using TMPro;

public class Deck : MonoBehaviour {

    public GameObject card;
    public GameObject cardGhosts;
    public Vector3[] newCardSpawnLocations;
    public int handSize = 3;

    public AnimationCurve customSlideAnimation;

    [Tooltip("The Cards in Your Deck")]
    public List<SingleCard> cardPool;
    [Tooltip("The Cards in Hand")]
    public List<SingleCard> cardsInHand;
    public List<GameObject> handCardObjects;
    [Tooltip("The Cards in Your Graveyard")]
    public List<SingleCard> discardPool;
    public List<SingleCard> grabBagPool;

    public GameObject goodbyeParticle;
    public TextMeshPro deckCount;
    public TextMeshPro discardCount;

    public bool loadingNewCard = false;
    public bool currentlyShopping = false;

    AudioSource shuffleSFX;

    // Start is called before the first frame update
    void Start() {
        cardPool = new List<SingleCard>();
        cardsInHand = new List<SingleCard>();
        discardPool = new List<SingleCard>();
        shuffleSFX = GetComponent<AudioSource>();

        //
        //Generates the deck here

        //Hearts and Clubs
        for (int suit = 1; suit < 4; suit += 2) {
            for (int value = 1; value < 5; value++) {
                SingleCard tempCard = new SingleCard(value, suit);
                cardPool.Add(tempCard);
            }
        }
        //Diamonds and Spades
        for (int numSets = 0; numSets < 2; numSets++) {
            for (int suit = 0; suit < 4; suit += 2) {
                for (int value = 1; value < 5; value++) {
                    SingleCard tempCard = new SingleCard(value, suit);
                    cardPool.Add(tempCard);
                }
            }
        }


        //cardPool.Add(new SingleCard(4, CardDisplay.Suit.CURSE));
        //cardPool.Add(new SingleCard(4, CardDisplay.Suit.BLESS));

        //Draw the starting hand
        for (int i = 0; i < handSize; i++) {
            DrawCard();
        }
    }

    float timeCountDown = 2f;
    // Update is called once per frame
    void Update() {
        //Death Reset
        if (Time.timeScale == 0 && Input.anyKeyDown) {
            SceneManager.LoadScene(1);
            Time.timeScale = 1f;
        }

        //Shuffle test
        if (Input.GetKeyDown(KeyCode.Alpha9)) {
            discardPool.AddRange(cardPool);
            cardPool.Clear();
            UpdateNumCardsEachZone();
            StartCoroutine(BackendDraw());
        }
    }

    public void UpdateNumCardsEachZone() {
        deckCount.text = cardPool.Count + "";
        discardCount.text = discardPool.Count + "";
    }

    /// <summary>
    /// Draw multiple cards at once
    /// </summary>
    /// <param name="numCardsToDraw"> The number of cards to draw at once</param>
    public void DrawCards(int numCardsToDraw) {
        for (int i = 0; i < numCardsToDraw; i++) {
            DrawCard();
        }
    }

    /// <summary>
    /// Call this function to draw ONE card
    /// </summary>
    public void DrawCard() {
        loadingNewCard = true;
        StartCoroutine(BackendDraw());
    }

    public void NaturalDraw() {
        loadingNewCard = true;
        StartCoroutine(BackendDraw());
    }

    IEnumerator BackendDraw() {
        if (cardPool.Count == 0) {
            //If you still don't have a deck, just give up
            if (discardPool.Count == 0) {
                yield break;
            }
            cardPool.AddRange(discardPool);
            shuffleSFX.Play();
            yield return StartCoroutine(ShuffleEffect());
        }

        while(currentlyShopping) {
            yield return null;
        }

        //Remove a random card from the deck
        int drawnCardIndex = Random.Range(0, cardPool.Count);
        SingleCard newCard = cardPool[drawnCardIndex];
        cardPool.RemoveAt(drawnCardIndex);
        UpdateNumCardsEachZone();

        //Add that card to the hand pile
        cardsInHand.Add(newCard);

        //Instantiate a single card object
        GameObject newCardObject = Instantiate(card, newCardSpawnLocations[0], Quaternion.Euler(0, 0, 45), transform);
        newCardObject.GetComponent<SingleCard>().SetValues(newCard, newCardObject);
        newCard.SetValues(newCardObject);
        handCardObjects.Add(newCardObject);

        //Push in from the bottom on left most side
        StartCoroutine(slideInNewCard(newCardObject));
    }

    IEnumerator ShuffleEffect() {
        float timeSinceStart = 0f;
        float timeForEffect = shuffleSFX.clip.length * .9f;
        int numGhostsToSpawn = discardPool.Count;
        discardPool.Clear();
        float timeBetweenEachGhost = (timeForEffect / 2f) / numGhostsToSpawn;

        List<GameObject> ghostsAlreadySpawned = new List<GameObject>();

        int numGhostsSpawned = 0;

        //Actual start of shuffle effect
        while (timeSinceStart < timeForEffect) {
            timeSinceStart += Time.deltaTime;
            yield return null;
            if (numGhostsSpawned < numGhostsToSpawn) {
                if (numGhostsSpawned * timeBetweenEachGhost < timeSinceStart) {
                    //Spawn a Ghost
                    GameObject newGhost = Instantiate(cardGhosts, discardCount.transform.position, Quaternion.identity, transform);
                    numGhostsSpawned++;
                    Destroy(newGhost, timeForEffect - timeSinceStart + .1f);
                    ghostsAlreadySpawned.Add(newGhost);

                }
            }

            for (int i = 0; i < ghostsAlreadySpawned.Count; i++) {
                float xPos = Mathf.Lerp(
                    7.4f, -7.4f,
                    customSlideAnimation.Evaluate(
                        (timeSinceStart - i * timeBetweenEachGhost) / (timeForEffect / 2))
                );

                float yPos = -0.04565f * Mathf.Pow(xPos, 2) - 2f;
                ghostsAlreadySpawned[i].transform.position = new Vector3(xPos, yPos, 0);

            }
        }
        //Cleanup
        ghostsAlreadySpawned.Clear();
    }

    public void AddGrabBagCard(SingleCard cardToAdd) {
        grabBagPool.Add(cardToAdd);
    }
    public SingleCard GetGrabBagCard() {

        if(grabBagPool.Count >= 1) {
            int index = Random.Range(0, grabBagPool.Count);
            SingleCard card = grabBagPool[index];
            grabBagPool.RemoveAt(index);
            return card;
        }
        else {
            int suit = Random.Range(0, 4);
            int value = Random.Range(1, 4);
            return new SingleCard(value, (CardDisplay.Suit)suit);
        }
    }


    /// <summary>
    /// Moves parameters and cards from zone to zone. Does NOT call an effect. 
    /// </summary>
    /// <param name="cardThatWasPlayed">The SingleCard script attached to the played card</param>
    public void CardPlayed(SingleCard cardThatWasPlayed) {
        for (int i = 0; i < cardsInHand.Count; i++) {
            if (cardThatWasPlayed.gameObject == handCardObjects[i]) {

                handCardObjects[i].GetComponent<BoxCollider2D>().enabled = false;

                //Move the card to a new zone
                discardPool.Add(cardsInHand[i]);
                cardsInHand.RemoveAt(i);

                UpdateNumCardsEachZone();

                //Create the discard particle
                Instantiate(goodbyeParticle, handCardObjects[i].transform.position, Quaternion.identity);
                handCardObjects.RemoveAt(i);

                Destroy(cardThatWasPlayed.gameObject);

                //Shift the cards around
                StartCoroutine(AdjustAllCardPositions());
                return;
            }
        }
        Destroy(cardThatWasPlayed.gameObject);
    }

    public float timeToSlideInNew = 1f;
    /// <summary>
    /// Moves a new card from off screen into the hand
    /// </summary>
    /// <param name="newestCard">The object of the new card</param>
    /// <returns></returns>
    IEnumerator slideInNewCard(GameObject newestCard) {
        yield return new WaitForFixedUpdate();



        while (currentlyShopping) {
            yield return null;
        }

        //Adjust the render order to display properly
        for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) {
            handCardObjects[cardIndex].GetComponent<SingleCard>().SetSortingValue(-2 * cardIndex, true);
        }

        //Set new card location according to theoretical arch
        Vector3 newCardLocation = new Vector3(-8, 0, 10);
        newCardLocation.y = -0.05f * Mathf.Pow(newCardLocation.x, 2) - 4f;

        newestCard.transform.position = newCardLocation;

        newestCard.GetComponent<SingleCard>().RefreshJumpingValues();

        StartCoroutine(AdjustAllCardPositions());
    }


    public float timeToAdjustAllCards = 1f;
    /// <summary>
    /// Adjust the location of all cards in hand to the correct positions
    /// </summary>
    /// <returns></returns>
    IEnumerator AdjustAllCardPositions() {
        float timeSinceStart = 0f;

        while (currentlyShopping) {
            yield return null;
        }

        while (timeSinceStart < timeToAdjustAllCards) {
            yield return null;

            for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) {
                float targetXPos = 0;

                //Calculate the target position for the current card
                if (cardsInHand.Count == 2) {
                    targetXPos = 2 - (cardIndex * 4f / (cardsInHand.Count - 1f));
                }
                else if (cardsInHand.Count > 2) {
                    targetXPos = 4 - (cardIndex * 8f / (cardsInHand.Count - 1f));
                }
                float targetYPos = EvaluateHandEquation(targetXPos);

                if (!handCardObjects[cardIndex]) {
                    continue;
                }

                Transform currentCardTrans = handCardObjects[cardIndex].transform;

                //
                //Only sets values for cards not in slot & Not being held
                if (!handCardObjects[cardIndex].GetComponent<DragTransform>().inSlot &&
                    !handCardObjects[cardIndex].GetComponent<DragTransform>().dragging) {

                    //Moves and rotates cards appropriately
                    Vector3 startingPos = handCardObjects[cardIndex].GetComponent<SingleCard>().startingPos;
                    float currentXPos = Mathf.Lerp(startingPos.x, targetXPos, customSlideAnimation.Evaluate(timeSinceStart / timeToAdjustAllCards));
                    float currentYPos = EvaluateHandEquation(currentXPos);

                    currentCardTrans.position = new Vector3(currentXPos, currentYPos, 2 * cardIndex);

                    float angle = Mathf.Lerp(20, -20, (currentXPos + 4) / 8);
                    if (angle < 0) {
                        angle += 360;
                    }
                    currentCardTrans.rotation = Quaternion.Euler(0, 0, angle);
                }
            }

            timeSinceStart += Time.deltaTime;
        }

        //Update Reset Positions
        for (int cardIndex = 0; cardIndex < cardsInHand.Count; cardIndex++) {
            if (!handCardObjects[cardIndex].GetComponent<DragTransform>().inSlot &&
                    !handCardObjects[cardIndex].GetComponent<DragTransform>().dragging) {
                handCardObjects[cardIndex].GetComponent<SingleCard>().RefreshJumpingValues();
            }

            else {
                float targetXPos = 0;
                if (cardsInHand.Count == 2) {
                    targetXPos = 2 - (cardIndex * 4f / (cardsInHand.Count - 1f));
                }
                else if (cardsInHand.Count > 2) {
                    targetXPos = 4 - (cardIndex * 8f / (cardsInHand.Count - 1f));
                }
                float targetYPos = EvaluateHandEquation(targetXPos);
                float angle = Mathf.Lerp(20, -20, (targetXPos + 4) / 8);
                if (angle < 0) {
                    angle += 360;
                }
                handCardObjects[cardIndex].GetComponent<SingleCard>().RefreshJumpingValues(new Vector3(targetXPos, targetYPos, 2 * cardIndex), Quaternion.Euler(0, 0, angle));
            }
        }
        loadingNewCard = false;
    }

    public float EvaluateHandEquation(float xAxis) {
        return -0.05f * Mathf.Pow(xAxis, 2) - 4f;
    }

}



/*
 * Old alternative method of adding new cards
Slide new card in from directly below

//Slide in according to the animation curve
while (timeSinceStart < timeToSlideInNew) {
    yield return null;
    newestCard.transform.position = Vector3.Lerp(newCardSpawnLocations[0], newCardSpawnLocations[1], customSlideAnimation.Evaluate(timeSinceStart / timeToSlideInNew));
    timeSinceStart += Time.deltaTime;
}

SingleCard.cs

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

public class SingleCard : MonoBehaviour {
    public bool debugTesting = false;

    public bool isGrabBagCard = false;

    public int cardValue;
    public CardDisplay.Suit cardSuit;

    [Tooltip("1,2,3,4,5")]
    public GameObject[] valueDisplayPrefabs;

    CardDisplay ownDisplay;
    GameObject ownDisplayObject;
    public Transform currentTrans;
    SpriteRenderer renderBox;

    AudioSource SFXbox;
    public AudioClip[] dealSounds;


    public Vector3 startingPos;
    public Quaternion startingRotation;
    public int startingLevel;

    public CardSlotHolder GrabBagHolder;


    public SingleCard(int outsideValue, int outsideSuit) {
        cardValue = outsideValue;
        cardSuit = (CardDisplay.Suit)outsideSuit;
    }

    public SingleCard(int outsideValue, CardDisplay.Suit outsideSuit) {
        cardValue = outsideValue;
        cardSuit = outsideSuit;
    }

    // Start is called before the first frame update
    void Start() {
        renderBox = GetComponent<SpriteRenderer>();
        ResetDisplay();

        SFXbox = GetComponent<AudioSource>();
        SFXbox.clip = dealSounds[Random.Range(0, dealSounds.Length)];
        SFXbox.Play();
    }

    // Update is called once per frame
    void Update() {
        if (debugTesting) {
            debugTesting = false;
            RandomDisplay();
        }
    }

    void RandomDisplay() {
        cardValue = Random.Range(6, 8);
        cardSuit = (CardDisplay.Suit)Random.Range(4, 7);
        ResetDisplay();
    }

    public void ResetDisplay() {
        if (cardValue <= 0) {
            if (ownDisplayObject) {
                Destroy(ownDisplayObject);
            }
            ownDisplayObject = null;
            return;
        }


        if (ownDisplayObject) {
            Destroy(ownDisplayObject);
        }
        if(cardValue >= 10) {
            cardValue = 10;
        }
        ownDisplayObject = Instantiate(valueDisplayPrefabs[cardValue - 1], transform.position + new Vector3(0, 0, -1), transform.rotation, transform);
        ownDisplay = ownDisplayObject.GetComponent<CardDisplay>();
        ownDisplay.currentSuit = cardSuit;
        ownDisplay.resetDisplay();
    }


    public void SetValues(GameObject otherObject) {
        currentTrans = otherObject.transform;
    }
    public void SetValues(SingleCard otherCard, GameObject otherObject) {
        cardValue = otherCard.cardValue;
        cardSuit = otherCard.cardSuit;
        currentTrans = otherObject.transform;
        ResetDisplay();
    }
    public void SetValues(SingleCard otherCard, GameObject otherObject, CardSlotHolder CSH) {
        SetValues(otherCard, otherObject);
        GrabBagHolder = CSH;
    }

    public void SetSortingValue(int newSortingLevel, bool isMovingUp) {
        StartCoroutine(LateSetSorting(newSortingLevel, isMovingUp));
    }
    IEnumerator LateSetSorting(int newSortingLevel, bool isMovingUp) {
        if (isMovingUp) {
            yield return new WaitForFixedUpdate();
            if (ownDisplay) {
                ownDisplay.layerOrder = newSortingLevel + 1;
                ownDisplay.resetDisplay();
            }
            yield return new WaitForFixedUpdate();
            yield return new WaitForFixedUpdate();
            renderBox.sortingOrder = newSortingLevel;
        }
        else {
            yield return new WaitForFixedUpdate();
            renderBox.sortingOrder = newSortingLevel;
            yield return new WaitForFixedUpdate();
            yield return new WaitForFixedUpdate();
            if (ownDisplay) {
                ownDisplay.layerOrder = newSortingLevel + 1;
                ownDisplay.resetDisplay();
            }
        }
    }



    public void RefreshJumpingValues() {
        startingPos = currentTrans.position;
        startingRotation = currentTrans.rotation;
        startingLevel = currentTrans.GetComponent<SpriteRenderer>().sortingOrder;
    }
    public void RefreshJumpingValues(Vector3 position, Quaternion rotation) {
        startingPos = position;
        startingRotation = rotation;
    }

    bool isInProgress = false;
    bool inProgressState = false;
    void OnMouseEnter() {
        //Lerp position to y = -3.5
        //set z rotation to 0
        //set sorting value to 2
        DragTransform DT = GetComponent<DragTransform>();
        if (DT.IsDragging() || DT.inSlot) {
            return;
        }
        StopAllCoroutines();
        AnimationCancel();
        StartCoroutine(HoverMoveUp(true));
    }
    void OnMouseExit() {
        //
        //Check to see if dragging is true
        //If so, do nothing
        //Otherwise, trigger the lerp back to correct position
        //
        DragTransform DT = GetComponent<DragTransform>();
        if (DT.IsDragging() || DT.inSlot) {
            return;
        }
        StopAllCoroutines();
        AnimationCancel();
        StartCoroutine(HoverMoveUp(false));
    }

    void AnimationCancel() {
        StopAllCoroutines();

        if (isInProgress) {
            if (inProgressState) {
                transform.position = new Vector3(startingPos.x, -3.5f, startingPos.z);
                transform.rotation = Quaternion.identity;
            }
            else {
                transform.position = startingPos;
                transform.rotation = startingRotation;
            }

            SetSortingValue((inProgressState) ? 2 : startingLevel, inProgressState);
        }
    }

    public float timeToMoveSpots = 0.5f;
    IEnumerator HoverMoveUp(bool isMovingUp) {
        isInProgress = true;
        inProgressState = isMovingUp;

        float timeSinceStart = (isMovingUp) ? 0f : timeToMoveSpots;

        while ((isMovingUp && timeSinceStart < timeToMoveSpots) || (!isMovingUp && timeSinceStart > 0)) {
            yield return null;
            transform.position = Vector3.Lerp(startingPos, new Vector3(startingPos.x, -3.5f, startingPos.z), timeSinceStart / timeToMoveSpots);
            transform.rotation = Quaternion.Slerp(startingRotation, Quaternion.identity, timeSinceStart / timeToMoveSpots);

            timeSinceStart += (isMovingUp) ? Time.deltaTime : -1 * Time.deltaTime;
        }

        yield return LateSetSorting((isMovingUp) ? 2 : startingLevel, isMovingUp);
        isInProgress = false;
    }

    public override string ToString() {
        return cardValue + " of " + cardSuit + "s";
    }
}