10.2b — ScriptableObjects: Card Data as Assets

The ScriptableObject, defined. It is a data class that becomes a FILE in your project (an asset, like a sprite). The template already ships one — open Assets/Scripts/Card_data.cs and read it:

[CreateAssetMenu(fileName = "Card_data", menuName = "Cards/Card_data", order = 1)]
public class Card_data : ScriptableObject
{
    public string card_name;
    public string description;
    public int health;
    public int cost;
    public int damage;
    public Sprite sprite;
    public int fontSize = 36;
}

Each field is one row of a card, and each ASSET you create from this class is one card, editable in the Inspector. Right-click in Assets → Create → Cards → Card_data and an .asset file appears. Open that file and you get fields, not code: designers edit these, and programmers build the shape once. The code half below takes every line of the class apart.

Your project already has two cards, and together they show you both ends of the pipeline. Open Assets/Cards/Card_Data/ and compare them side by side. Orc_Data.asset is filled in: a name, a description, health, cost, damage and a sprite. Unicorn_data.asset is empty in every single field — a card that was created and never written. Same class, same Inspector, two very different amounts of work.

Now find the last thing in Assets/Scripts/Card.cs:

if (card_name == "Orc")
{
    background.color = Color.chocolate;
}

That is where an asset meets the code. The card's name is not a string somebody typed into a script — it is data.card_name, copied onto the card by Start(), and "Orc" is exactly what the Orc asset says. Rename that asset in the Inspector and this branch stops running. Data you can edit with the mouse just decided what the code does.

Compare your three data homes so far:

Data lives in…	Example you built	Edited by
Serialized fields on a component	the playerTransform reference wired in the Inspector (3.1)	Inspector, per scene object
Scene/prefab YAML	everything (9.4)	Unity (and you, by hand, once)
ScriptableObject assets	your cards	Inspector, in the PROJECT, reusable everywhere

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[CreateAssetMenu(fileName = "Card_data", menuName = "Cards/Card_data", order = 1)]
public class Card_data : ScriptableObject
{
    public string card_name;
    public string description;
    public int health;
    public int cost;
    public int damage;
    public Sprite sprite;
    public int fontSize = 36;
}

    public string rarity;

    public string rarity;
    public TextMeshProUGUI rarityText;
        sprite = data.sprite;
        rarity = data.rarity;
        damageText.text = damage.ToString();
        rarityText.text = rarity;

// ------------------------------------------------------------------
//  REFERENCE FILE — Assets/Scripts/Card_data.cs and Assets/Scripts/Card.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.
// ------------------------------------------------------------------
// Assets/Scripts/Card_data.cs — the whole file, as it stands after this lesson.
// It SHIPS with the project. The one line marked " + " is yours; the rest was
// already here and is not retyped.

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

[CreateAssetMenu(fileName = "Card_data", menuName = "Cards/Card_data", order = 1)]
public class Card_data : ScriptableObject
{
    public string card_name;
    public string description;
    public int health;
    public int cost;
    public int damage;
    public Sprite sprite;
    public int fontSize = 36;
    public string rarity;                 // + added by you
}

// Assets/Scripts/Card.cs — additions only, and only the parts that changed.
// The other fifty lines of the file are already there. Do not retype them.

    public string rarity;                 // + with the other value copies
    public TextMeshProUGUI rarityText;    // + with the other TMP references

    void Start()
    {
        card_name = data.card_name;
        description = data.description;
        health = data.health;
        cost = data.cost;
        damage = data.damage;
        sprite = data.sprite;
        rarity = data.rarity;             // + beside the other six copies
        nameText.text = card_name;
        nameText.fontSize = data.fontSize;
        descriptionText.text = description;
        healthText.text = health.ToString();
        costText.text = cost.ToString();
        damageText.text = damage.ToString();
        spriteImage.sprite = sprite;
        rarityText.text = rarity;         // + a string, so no .ToString()
    }

Step 1 — the code half above is this step's work. If you have not done it yet, do it now: the rest of this lab assumes a card can show a field you invented.

Step 2 — author five cards. In the Project window, right-click → Create → Cards → Card_data. The new file arrives called Card_data, so rename it to the card before you do anything else or your project fills up with Card_data 1, Card_data 2 and no way to tell them apart in a deck list. Fill each one in the Inspector, keep them together in Assets/Cards/Card_Data/ beside the two that ship, and give each card a number that makes it different from the others — a card that costs the same and hits the same as every other card is not a card, it is the same card wearing a different name. Five is today; a jam deck wants fifteen to twenty of them.

Step 3 — put them in the deck. No new field, and no code. GameManager.cs already declares the list the Inspector edits:

public List<Card_data> player_deck = new List<Card_data>();

Hierarchy → select Dealer — the object carrying GameManager — and player_deck is waiting: an element count, then one slot per card. Drag your assets in. Duplicate entries are legal — three copies of your best card is a design decision that costs three slots and one asset file. Read the slots that are already there before you fill them: a slot showing None is a null reference sitting in the list, and Deal() reads player_deck[0] and hands whatever it finds straight to Card.Start(), which reads data.card_name on the first frame. An empty slot is not a harmless one.

Then notice how little Deal() does with all that work: it instantiates one card per side and reads index [0]. A deck of twenty and a deck of one look identical on screen today — you are stocking a list that the shuffle in 10.2c is going to need before it can mean anything.

And read one more line while you are in there. The last line of Deal() turns DraggableUI off on the player's card and leaves it on for the AI's. The drag behaviour ships with the project, and the scene ships the Canvas and EventSystem that UI dragging needs. Which card gets to be dragged, though, is a decision somebody made — read the line and decide whether it is a bug or a rule, and say which one you would have written.

Step 4 — prove the pipeline. Add a card WITHOUT touching code: create, fill, drag into the deck, play. If that took under two minutes, your content pipeline works and the rest of the jam is content rather than plumbing. The proof is not that a new card exists — it is that you never opened a script to make it.