2. Cards¶
2.1 How a card is drawn¶
A card is drawn by one material (M_QC_CardUI) on a flat image. For every pixel it traces the view ray to
the tilted card and to each art layer, so the card turns in real perspective and its layers move against each other
(parallax) without any 3D mesh. The card stays rigid: it tilts, it never bends.
- Layers: up to 8, drawn back to front by depth (at the same depth frames first, then list order), so what the parallax shows and what covers what always agree. A layer at depth 0 moves with the card; deeper layers move less, layers in front move more.
- Depth limits: the first slot is the back of the card (the background): no slot goes deeper, so art pushed back stops there instead of vanishing behind it. Pop-out (Unclipped) slots stay in front of the frame, and so does the text. A frame is always on the surface (depth 0; it has no Depth setting): at any other depth its window slides over the art. The template's depth slider starts at the slot's limit, and an edited depth snaps to it.
- Lined up at rest: whatever the depth, a layer shows exactly its art when the card faces the viewer.
- The frame's window: a Frame slot sits on the card's surface; its transparent area is the card's window. Next to an Art slot, a frame looks the same until art sits in front of it. A card instance's finish On Frame goes on it. Clipped layers in front of it show only through that window, so the illustration can sit in front of the frame, closer to the viewer, and still stay inside it: it moves against the background, so the card reads as deep. A second frame (e.g. a foil frame) draws over the first.
- Clipped and unclipped layers: layers are visible only inside the card's outline (and window), except Unclipped layers, which draw over and beyond the frame (pop-out art).
- Any art, any shape: each layer fits its art to the card: Cover (fills the card, crops what overflows, centered), Contain (shows all of it, empty space around) or Stretch; plus scale and offset per card.
- Blend modes: Normal, Additive (glows, sparks), Multiply (shadows, ink), Screen (haze).
- Auto overscan: an Auto Overscan layer (backgrounds) is enlarged just enough that its edges never show, up to the max tilt plus room for spring overshoot.
- Back: past 90 degrees the card shows its back art, mirrored as a real card's back would be.
- Edge, shadow, sheen: the card's thickness shows as an edge when it tilts; a soft drop shadow; a soft highlight from a fixed virtual light moves across the card as it tilts (it shows when the card's top-left turns toward the viewer; the stronger, art-aware shine comes from finishes).
- Corners: rounded and anti-aliased at any size. The material cuts the card's outline, so frame and back art should run out to the texture's edges rather than draw their own rounded corners.
2.2 Template (UQuickCardsTemplate, Content Browser > QuickCards > Template)¶
The layout every card of a kind shares. Presets: DA_QC_Template_Simple and DA_QC_Template_FullArt (duplicate one
and edit it: your copy's slot Default Textures are the shared art, e.g. background and frame, for every card on it).
| Setting | Default | Notes |
|---|---|---|
| Card Size | 63 × 88 | Only the shape (height / width) matters |
| Corner Radius | 0.045 | Card widths |
| Thickness | 0.012 | Card widths; 0 = no edge |
| Edge Color | warm white | |
| Slots | none (presets below) | Up to 8 |
| Text Depth | 0 | Slots section. Card widths, like a slot's depth; 0 = on the surface, moving with the frame; never behind the frame (a background raised in front of the frame leaves the text on the frame's plates); without a frame, never behind the back of the card |
| Fields | Cost, Attack, Health, Type | The values every card of the template has, where each shows and in what color (section 2.9) |
| Text Layout | WBP_QC_TextLayout_Simple |
A QuickCards Text Layout widget (section 2.9); none = no text |
| Back Texture | placeholder back | Cards can override it |
| Back Fit | Cover |
A template is the standard its cards start from. A card fills in its art and values, and overrides only what it changes: a field's spot or color, its back.
Slot settings:
| Setting | Default | Notes |
|---|---|---|
| Name | Shown on every card using the template; renaming keeps every card's art for the slot | |
| Kind | Art | Art (drawn at its depth) or Frame (the card's border, on the surface; its transparent area is the window that art in front of it is cut to) |
| Depth | 0 | Card widths from the surface; negative = behind. Decides draw order; limits in section 2.1. Not shown for a frame (always 0) |
| Fit | Cover | Cover / Contain / Stretch; cards can override it |
| Blend | Normal | Normal / Additive / Multiply / Screen |
| Unclipped | off | Draw beyond the card's outline (pop-out) |
| Auto Overscan | off | Enlarge just enough that the edges never show (backgrounds) |
| Extent | 1 | Layer size relative to the card (when Auto Overscan is off) |
| Default Texture | none | Art for cards that leave the slot empty (e.g. the frame) |
| Enabled | on |
Presets (depth in card widths):
| Template | Slots |
|---|---|
| Simple | Background (-0.30, auto overscan), Illustration (-0.20, inside the card, seen through the frame's window), Frame (0, frame) |
| Full Art | Background (-0.40, auto overscan), Back Effect (-0.30, auto overscan), Illustration (-0.20) and Illustration Front (-0.17) inside the card, Frame (0, frame), Front Effect (+0.11, auto overscan), Pop-out (+0.14, unclipped, extent 1.3) |
Every preset's Frame slot defaults to the placeholder frame; art slots start empty.
2.3 Card (UQuickCardsCardDefinition, Content Browser > QuickCards > Card)¶
One card. A new card starts on the Simple template with its name taken from the asset. Its Details panel has three sections: Card (what the card is), Overrides (what it changes from its template) and Gameplay (optional data for your game's own logic).
| Setting | Default | Notes |
|---|---|---|
| Template | Simple | Card: the standard the card starts from |
| Display Name | asset name | Localizable; {Name} in text |
| Art | one row per template slot | The rows follow the template; empty slots use the template's art |
| Description | none | The card's main text, e.g. "Deal {Attack} damage." ({Field} shows a field's value) |
| Fields | one row per template field | Value (a number or a text, by the field's type), plus optional Location and Color for this card only |
| Back Texture | none | Overrides: the template's back |
| Tags | none | Gameplay: Gameplay Tags |
| Fragments | none | Gameplay: reusable data or behavior (subclasses of QuickCards Fragment) |
Art row settings: Texture (any size or shape), Fit (override the slot's), Scale (1; 0.5 = half size), Offset (card sizes, x right, y down), Visible (on), Finish (optional, on this layer only: Holo on the Illustration, Reverse Holo or Gold on the Frame). Reset to Default on any row setting goes back to its default (Scale 1).
In the card's Details: under Fields, how to show a field in the Description and what doesn't show: a
{placeholder} that isn't a field (a typo shows empty), a field whose spot an earlier field takes, a spot the text
layout lacks. Under Art, a finish left out because the card uses more than two.
Cards saved before fields (with Text and Stats lists) move over when they load: Rules becomes the Description, stats and numbers typed as text fields become field values; anything the template has no field for is named in the log.
Blueprint: GetStat, GetTextField, GetFieldLocation, GetFieldColor, GetFieldAt, FindFragment (returns
the requested class), SyncToTemplate.
2.4 Deck (UQuickCardsDeck, Content Browser > QuickCards > Deck)¶
A deck: a name and a deck table, one row per card with its copies. A row describes a card, or points to a Card asset you made (for a hand-tuned card). The table is the deck's only list of cards. Also a pack's pool or a character's cards.
| Setting | Default | Notes |
|---|---|---|
| Display Name | asset name | Localizable |
| Table | DT_<deck name> |
A DataTable of QuickCards Deck Rows: one row per card (below). A new Deck makes it next to itself, with an example row |
| Rarities | DA_QC_Rarities_Basic (new decks) | Optional: the rarities its rows pick from and their pack chances (§6.1). Needed to open packs of the deck; no effect on the look |
Described cards are built, not saved: when the game (or the editor) first asks for the deck's cards, a card is made in memory from each row that describes one. There are no card assets to keep in step and no sync step; edit the table and the deck follows (in the editor at once). A card that needs hand tuning (art scale and offset, extra layers, its own finish per slot) is a Card asset that a row points to: e.g. commons described in the table plus a few hand-made specials.
The deck's Details panel opens with a Cards section: a summary (cards and copies), New Card... (makes a Card
asset where you choose, on the template of the table's last row, adds a row for it and opens it), Add Card (pick
a Card asset you have: adds a row pointing to it; picking one already in the deck adds a copy to its row), Open
Table (or New Table when the deck has none: makes DT_<Deck> with an example row, uses it and opens it), what's
wrong in the table's rows (a field or slot the row's template lacks, a number field given text, a card or template
that doesn't load), and the deck's cards in a list with a live preview of the selected one (drag it to tilt).
Deck table (DataTable, row type QuickCards Deck Row; or a CSV imported into one): one row per card.
| Column | Notes |
|---|---|
| (Row name) | Names the card (Find Card) and, if Display Name is empty, is its name |
| Display Name | Card name shown to players |
| Card | Optional: a Card asset. When set, the row is that card and only Count and Rarity matter (the row editor hides the other columns) |
| Count | Copies in the deck (1) |
| Rarity | Optional: one of the deck's Rarities, picked from a list (the rarities of the project's Rarities assets; a CSV gives the name). Packs only; empty = never in packs. A name the deck's Rarities lack is listed as a problem |
| Template | Simple for a new row; e.g. Full Art (one deck can mix them). Empty uses Simple and says so |
| Illustration | Art for the template's main slot (Illustration, else its first art slot) |
| Illustration Scale | 1 = as the template fits it; 0.8 smaller, 1.5 larger (0.1 to 3). Also on an Illustration Front slot, so split art stays lined up |
| Illustration Offset | Moves the illustration in card sizes, X right, Y down (0, 0); with the scale |
| Background, Frame | Shown as Background Override and Frame Override: this card's own; empty shows the template's shared art |
| Illustration Finish, Frame Finish | Optional: a finish on the main art, on the frame |
| Description | The card's main text, as on a card |
| Fields | Field name → value (Attack 3, Type Demon); fields left empty are 0 or empty. Picking a template lists its fields here |
| Template Layers | The template's other art slots, by name (Full Art: Back Effect, Illustration Front, Front Effect, Pop-out). Picking a template lists them here (a notification names the ones added); empty ones show the template's art |
| Advanced Layer Placement | Off. Ticked, Layer Placement shows and applies; unticked, the card uses the template's placement (values kept) |
| Layer Placement | Shown with Advanced Layer Placement: the template's other layers (as Template Layers), each with Scale (1; 0.1 to 3) and Offset (0, 0; card sizes, X right, Y down). Ticking lists them; non-default values for a layer the template lacks stay (and are reported) |
| Tags | Gameplay Tags for your game (e.g. Element.Fire) |
Sections: the row editor groups a row's columns as Card (Card, Count, Rarity, Display Name, Template, Description, Fields, Tags) and Art, in layer order: Background Override, Illustration, Illustration Scale, Illustration Offset, Illustration Finish, Frame Override, Frame Finish, Template Layers. A CSV still has one plain column each (Background, Frame, TemplateLayers...).
The row editor follows the template: when you edit a row in the editor, its Fields and Template Layers lists change to the row's template, and the row editor shows them at once: its fields and other art slots appear, ready for values, and empty entries the template doesn't have go. Entries with a value stay, and the deck lists them as problems. (A DataTable has the same columns for every row, so Illustration, Background and Frame always show; a template without one of those slots reports art given for it.)
Shipped example (in QuickCards/Data/Examples): DA_QC_Card_Example (the Night Parade's Kappa as a Card asset,
the card a new card widget or 3D card shows); DA_QC_Card_Placeholder (Full Art with every kind of layer, placeholder
art); DT_QC_Deck_Example (Ember Imp and Stone Wall x3 Common, Spark
Sprite x2 Uncommon, Storm Drake Rare with a holo illustration, Gilded Golem Rare with a reverse holo frame, Elder Wyrm
Legendary on Full Art with a gold frame, and a row pointing to the placeholder Card asset, Rare) and
DA_QC_Deck_Example, the deck using it, on DA_QC_Rarities_Basic.
Blueprint: GetCards (each once, in table order), GetCopies (every copy), GetShuffledCopies(Seed) (the same
seed, the same order), GetCopyCount, GetCardAt(Index) (the copy at Index in deck order), FindCard(Name) (a row
name), ContainsCard, GetCountOf(Card), GetRarityOf(Card), play decks: CreatePlayDeck(Outer) (a copy the game changes while the deck
stays as designed; IsPlayDeck), AddCard(Card, Count, Rarity) (more copies, or the card at the end; a card the deck knew keeps its row
name and rarity), RemoveCard(Card, Count) (returns how many; the card leaves at 0), ClearCards (all in memory only; the table
never changes),
CreateInstances (a card instance per copy: a deck ready for play), SetTable, RefreshTableCards (starts over from
the table), and CreateCardFromRow (a row's Card asset, or a card built from the row, for cards your game makes as it
runs). Editor scripting: AddCardToDeck, CreateDeckTable, GetNewCardTemplate on the QuickCards Editor Library.
2.5 Rarity: for packs only¶
A deck's Rarities asset lists the rarities its rows pick from (§6.1); packs use them for their chances, guarantees and pity. Rarity never changes how a card looks: give a rare card a finish for that. (A rarity that drove the look was removed 2026-10-20; this one, 2026-10-22, only decides packs.) Read a card's with Get Rarity Of on its deck. For other ways to sort cards, use Gameplay Tags (Tags), fields or fragments.
2.6 Fragments (UQuickCardsFragment)¶
Make a Blueprint (or C++) subclass once, e.g. a Damage fragment with an Amount, then add it to any card with its own values. Find it with Find Fragment on a definition or instance.
2.7 Card Instance (UQuickCardsCardInstance)¶
A card in play: a definition plus what changed. Create with Create Card Instance. Number fields (Get Stat, Set
Stat, Add To Stat, Reset Stat, Is Stat Modified): the number on the card and every {Attack} in its
Description follow. Text fields and the Description (Get Text Field, Set Text Field, "Description" for the
description: changed for this card only). Colors (Get Field Color, Set Field Color, e.g. a buffed Attack in green:
coloring is your game's choice; Reset Field Color). Counters (Get / Set / Add To Counter), tags (Get Tags = the definition's plus added
ones, Has Tag, Add Tag, Remove Tag), Find Fragment.
Card-wide finish (Get Finish / Get Finish On: none until Set Finish gives one, on Frame, Art or Whole Card:
e.g. a reverse holo copy from a pack). Art rows with their own finish keep it.
Pattern seed (Get Pattern Seed / Set Pattern Seed): turns and shifts this copy's patterned finishes (Glitter,
Cracked Ice, Cosmos, Marble, Swirl) so no two copies shine alike; picked automatically (from the object's id) unless
set; 0 = automatic. Save it with the card to keep its look between sessions. A card widget or 3D card showing a
definition (no instance) has its own Pattern Seed setting: 0 = automatic from its name (the same every play).
On Changed fires after every change; cards showing the instance update, text included.
2.8 QuickCards Card widget (UQuickCardsCardWidget)¶
A UMG widget (palette category QuickCards). It keeps the card's shape inside whatever slot it gets and draws a
little beyond its slot (perspective, pop-out layers, shadow) without affecting layout. A new card shows the
example card (DA_QC_Card_Example: the demo's Kappa).
QuickCards | Card
| Setting | Default | Notes |
|---|---|---|
| Card Definition | example card (Kappa) | The card to show; a card instance set during play takes its place |
| Card Width | 315 | Slate units; the height follows the card's shape |
| Drag To Tilt | on | Dragging tilts the card. A hand turns it off for its cards (a drag moves them); untick it when your own widget moves cards |
QuickCards | Feel
| Setting | Default | Notes |
|---|---|---|
| Max Tilt Degrees | 25° | Largest tilt the card reaches, also after a hard flick on a bouncy feel (the spring stops there); 0 keeps the card flat |
| Drag Sensitivity | 0.15 | Degrees per Slate unit of drag |
| Dead Zone | 4 | Slate units before tilting starts (clicks stay clicks) |
| Invert X / Invert Y | off | By default dragging pushes the dragged edge away |
| Stiffness | 120 | Spring pull toward the target |
| Damping | 14 | Settling; about 2 × √Stiffness settles without overshoot |
| Return Delay | 0.08 s | Pause after release before springing back |
| Fling Inertia | on, 0.6 | Share of the drag's speed kept on a quick release |
| Parallax Strength | 1.0 | Scales every layer's depth |
| Perspective Strength | 0.8 | 0 = flat (orthographic), 1 = full perspective |
| Shine Strength | 0.3 | Light sheen; 0 = off |
| Clamp Shape | Circle | Circle limits total tilt; Box limits each axis |
| Camera Distance | 2.5 | Card widths; smaller exaggerates perspective |
| Hover Tilt | on | PC: the card leans toward the hovering mouse pointer; nothing depends on it |
| Hover Tilt Amount | 0.4 | Share of the max tilt |
| Hover Follow Speed | 8 | How quickly the lean follows (eases in and out) |
| Gyro Tilt | on | Phones: tilting the phone tilts the card; the phone's angle when the card appears (or is pressed) is its rest. No effect without motion sensors (no CPU either) |
| Gyro Strength | 0.5 | Negative turns the card the other way |
| Gyro Smoothing | 6 | Higher follows quicker, lower is smoother |
| Idle Sway | off | A resting card sways gently on its own (cards out of step) |
| Idle Sway Amount / Speed | 0.1 / 0.3 | Share of the max tilt; sways per second |
| Gamepad Tilt | on | A focused card tilts with the right stick; the confirm button (or Enter / Space) clicks it. The card can take keyboard focus while on |
| Gamepad Tilt Amount | 1 | Share of the max tilt |
QuickCards | Appearance
| Setting | Default |
|---|---|
| Pattern Seed | 0 |
| Shadow Opacity | 0.45 |
| Shadow Offset | (0.03, 0.045) card widths, right and down |
| Shadow Softness | 0.05 card widths |
QuickCards | Effects (card-wide, the Effects struct shared with 3D cards; they run on the material's time, so idle cards cost no CPU)
| Setting | Default | Notes |
|---|---|---|
| Edge Glow | off | A halo around the card's edge, plus a soft rim inside it |
| Edge Glow Color | warm gold | |
| Edge Glow Strength | 0.8 | 0.5 subtle, 1 strong |
| Edge Glow Width | 0.035 | Card widths past the edge |
| Edge Glow Pulse | 0.5 | Pulses per second; 0 = steady |
| Idle Shimmer | off | A soft light sweep across the face every few seconds; cards on screen together are staggered |
| Idle Shimmer Interval | 6 s | At least 1.5 s |
| Idle Shimmer Strength | 0.3 |
Play Reveal Sweep (Duration 0.8 s, Strength 1): one bright sweep across the face (a reveal, an upgrade); On Reveal Sweep Finished fires after. A pulsing glow or the shimmer makes the card repaint every frame (it's marked volatile); otherwise a resting card isn't repainted.
QuickCards | Advanced
| Setting | Default | Notes |
|---|---|---|
| Card Material | M_QC_CardUI |
Or a copy |
| Quad Scale | 1.35 | Room drawn around the card; raise it if pop-out art or the shadow is cut off |
Interaction: press on the card and drag (mouse or touch) to tilt it; it follows with a spring, and springs back to rest after release. Grabbing a moving card picks it up where it is. A second finger is ignored while one holds the card.
Blueprint: SetCardDefinition, SetCardInstance / GetCardInstance, GetShownDefinition, SetCardWidth,
SetFeel, RefreshCard (apply property changes), SetDragToTilt, SetLean (a lean on top of the card's own
motion, springing there with its feel; a hand leans a carried card), SetTilt / GetTilt (degrees; X pushes the right edge away,
Y the top edge), SetFlipAngle / GetFlipAngle (0 = front, 180 = back), IsBeingDragged, PlayRevealSweep,
GetCardMaterialInstance (for your own parameters in a copy of the material).
Events: On Card Clicked (released without dragging), On Card Drag Started, On Card Drag Ended, On Reveal Sweep Finished.
Flip and inspect (card widget): Flip Card (Duration 0.5 s) turns the card over, Show Side (Back, Duration) turns it to a side (0 s = at once), Is Showing Back, Is Flipping; On Card Flipped fires when a flip lands. Is Reveal Playing is true during a reveal sweep. Inspect On Click (off) opens the card in the inspect view when clicked (Inspect Widget Class: QuickCards Inspect or your Widget Blueprint made from it); Inspect does it from Blueprint; On Card Inspected fires.
2.8a QuickCards Inspect (UQuickCardsInspectWidget)¶
A card big in the middle of the screen over a dimmed background: drag to turn it (Feel: max tilt 40), tap it to flip it, tap outside or press Escape / the gamepad's back button to close (F or the gamepad's top button flips). Open it with Inspect Card (Card, Instance, Widget Class, Z Order) or a card widget's Inspect On Click; it opens with a short grow-and-dim and closes the same way, then removes itself (On Inspect Closed). Keyboard and gamepad focus go to the big card (right stick turns it).
| Setting | Default | Notes |
|---|---|---|
| Dim Color | black, 0.75 | Alpha is how much the background is covered |
| Card Screen Height | 0.7 | Share of the screen's height |
| Open Duration | 0.25 s | Opening and closing; 0 = at once |
| Flip Duration | 0.5 s | |
| Flip On Tap / Close On Background Tap | on / on | |
| Show Hint / Hint Text | on / "Drag to turn - Tap to flip - Tap outside to close" | Wraps on small screens |
| Feel | max tilt 40° | The big card's feel |
Restyle it: make a Widget Blueprint with QuickCards Inspect as its parent and name a QuickCards Card widget "Card" (optionally a Border "Dim", a Size Box "CardBox" and a Text "Hint"); without a "Card" the default layout is built. Open, Close, Flip, Get Card Widget, Is Closing.
2.8b QuickCards Card component and actor (3D cards)¶
A card in the world: QuickCards Card Actor (Place Actors panel > QuickCards category) or the QuickCards Card component
on any actor. The same card as the widget (layers with real depth, finishes, text, edge and rounded corners,
effects), drawn by M_QC_CardSurface on a quad in the card's front face. Its 3D look comes from the real camera, so
it works with any camera, moving or not, and costs no CPU while nothing changes. The front faces the component's +Z
(a new actor lies flat, face up: rotate it to stand it up); its top points along +X (the actor's forward), its right
along +Y. To stand a card up facing a camera that looks along +X, give it Pitch 90. The component's scale is set
from Card Width (the actor's root is a plain scene component, so scaling the actor still works).
| Setting | Default | Notes |
|---|---|---|
| Card Definition | example card (Kappa) | |
| Card Width | 30 cm | The height follows the card's shape |
| Parallax Strength | 1 | Scales the layer depths |
| Pattern Seed | 0 | Turns the patterned finishes on this card; 0 = automatic from its name (same every play). An instance's seed wins |
| Max Depth Angle | 30° | The steepest view angle the 3D look follows: seen from further to the side, the card turns but its layers stop sliding apart, so the art's edges never show. 89 = no limit |
| Shine Strength | 0.3 | The glare as you look from different angles; 0 = off |
| Effects | off | Edge Glow and Idle Shimmer, as on the widget |
| Card Material (Advanced) | M_QC_CardSurface |
Or a copy |
| Quad Scale (Advanced) | 1.35 | Room for the edge seen at an angle, pop-out art and the glow |
Blueprint: SetCardDefinition, SetCardInstance / GetCardInstance, GetShownDefinition, SetCardWidth,
RefreshCard, PlayRevealSweep, GetCardMaterialInstance; the actor's GetCardComponent.
Events: On Card Clicked (click or touch), On Card Hovered, On Card Unhovered (turn on the player controller's Enable Click Events and Enable Mouse Over Events), On Reveal Sweep Finished.
To turn a card over, rotate it: past 90 degrees its back shows. In the editor the card responds to the viewport camera.
2.9 Card text (QuickCards Text Layout)¶
A card shows its name, its Description and its template's fields.
Fields (on the template, in its Fields section): each is a value every card of the template has.
| Field setting | Default | Notes |
|---|---|---|
| Name | e.g. Attack: {Attack} in a Description, Get Stat / Set Stat in the game. Renaming keeps every card's value |
|
| Type | Number | Number (whole numbers show without decimals) or Text (a type line, flavor) |
| Location | Hidden | Hidden (not shown; the game and the Description can still use it), Top Left, Top Right, Bottom Left, Bottom Center, Bottom Right, Above Description |
| Color | white | The value's color |
The defaults: Cost (top left), Attack (bottom left), Health (bottom right), all numbers, and Type (a text, above the description). Add your own with + (e.g. Block). One field per spot: in the Details panel, picking a spot another field has swaps the two (Attack to Bottom Right puts Health at Bottom Left). Set from Blueprint or code, nothing swaps, and the first field at a spot shows (the card's Details name the other).
On a card, the Fields rows follow its template (no names to type): fill in each value. Tick a row's Location or Color to change it on that card only (e.g. Hidden: a spell without Attack); a spot another field shows at swaps them on that card.
Placeholders: the Description (and a text field) can show any field as {FieldName}: "Deal {Attack} damage."
Text and Rich Text blocks of a text layout can too, plus {Name} and {Description}. A placeholder without a value
is left empty. Names match ignoring case and can't contain spaces. {{ and }} write a brace.
Text layout (a Widget Blueprint with parent class QuickCards Text Layout, chosen by the template): lay it out
like any UI at its Design Width (Class Defaults, 630; the height follows the card's shape: 630 × 880 for a
standard card), any fonts and positions, a text box as large as you want. Its text is drawn at the project's Text
Resolution. Its spots are text blocks named TopLeft, TopRight, BottomLeft, BottomCenter,
BottomRight and AboveDescription: each shows the field placed there, in its color (all optional; move or restyle
them to move the spots).
The layout is drawn into a texture when the card's data changes (never per frame), and the card shows it on its surface, so the text tilts with the card. Art in front of the frame shows around the text, not over it.
Shipped: WBP_QC_TextLayout_Simple, used by both template presets: {Name} in the placeholder frame's name
plate, {Description} in its text box, the five border spots in bold white with a dark outline, and Above Description
just over the text box.
Blueprint: override Get Text Value in your layout to answer placeholders from your own game data (return false for keys you don't know); On Card Applied runs after the values are filled in (set images or colors from the card here; On Initialized doesn't run for card layouts). Card Definition and Card Instance are readable in the layout.