Blackjack, hold'em poker, spades, and uno. Four classic card games, each one a standalone Unreal Engine 5.7 project with a rules core that also runs as a graphical desktop client you can build in about ten seconds.
The screenshots below are the SDL2 client for each game, running. Same rules core the Unreal module uses, same card art, make gui to build and play it yourself.
Single player against the dealer: four-deck shoe with a cut card, hit/stand/double/split, S17 or H17, naturals at 3:2. Insurance didn't make the cut, on purpose. 344 headless checks on the rules core.
A pair of jacks split into three hands against a dealer ten, 300 out on the felt, decision pending on the last one.
No-limit Texas hold'em against three AI seats. Best-5-of-7 evaluator with full kicker cascades, generalized side pots, correct heads-up blind order. The AI plays pot odds and never emits an illegal action. 395 checks, including chip conservation over 30 complete games.
Hand 18, one pair on a queen-high turn, 48 to call and the raise slider live.
Partnership spades with bidding and nil. Follow-suit legality, the broken-spades rule, bags with the 10-bag penalty, first team to 500. Nil conventions vary table to table, so its README spells out exactly which ones apply here; 3,440 checks hold them in place.
Third trick of round 2, clubs led, spades not broken yet. The greyed cards in your hand are the ones you can't legally play.
Two to four players, the complete action-card set with the strict Wild Draw Four rule, reshuffles that never lose a card, rounds scored to 500. 352 checks, among them full AI-only games for every player count.
Round 6, yellow is live and play has reversed. Cards you can actually put down are the ones lit up.
Each game's README has the rules scope, the one-time editor wiring, and packaging commands.
blackjack/ single player vs dealer: betting, splits, doubles, the whole table flow
poker/ no-limit Texas hold'em against three AI seats, full hand evaluator, side pots
spades/ four-player partnership spades with bidding, nil, and bag penalties
uno/ 2-4 players, full action card set, round scoring to 500
Every folder holds the same three things: a rules core in plain C++, a graphical SDL2 client that runs anywhere a compiler does, and an Unreal 5.7 project that drives the identical core. The games share no code on purpose. Each one gets its own deck and card types shaped by what that game actually needs, instead of one over-general card framework that fits nobody. Per-game rules scope and build steps live in each game's own README.
Core game logic is plain C++17 with zero engine dependencies, under Source/<Module>/Core/ in each project. Rules, hand evaluation, AI opponents, scoring: all of it deterministic (RNG seeds are injectable) and testable without booting the editor.
Two front ends sit on top of that core and neither one owns a rule. The SDL2 client under gui/ is a few hundred lines that draw the table and forward clicks. The Unreal layer is a game mode, a controller, and UMG widget base classes in C++, with Blueprints only subclassing those widget bases to wire up visuals. Nothing in either front end decides what a legal move is; they both ask the core.
Two layers:
make testinside any game folder compiles that game's core logic with plain g++ and runs an assertion harness. No engine needed, finishes in seconds. This is what CI runs.- Unreal automation tests under
Source/<Module>/Tests/exercise the same logic through the engine. Run them from Session Frontend → Automation, or headless with-ExecCmds="Automation RunTests <Game>".
Built against UE 5.7, C++ for everything that matters. Each game's README lists the small amount of editor wiring needed after a fresh clone (a map, the game mode assignment, widget Blueprint subclasses).
Everything builds locally. There is no CI service in the loop and nothing here needs one.
cd blackjack # or poker, spades, uno
make gui # graphical client, the one in the screenshots
make play # same rules, terminal driver
make test # rules core assertions
The root Makefile fans those out across all four games: make test runs every suite, make gui builds every client, make shots re-renders the screenshots in this README, make art regenerates the card art. make on its own lists them.
make gui needs SDL2 and its image/ttf helpers. On Debian or Ubuntu that is apt install libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev; on macOS, brew install sdl2 sdl2_image sdl2_ttf. The client loads its art straight from that game's Art/ folder, so it runs from a clean checkout with no asset pipeline in between.
The Unreal build is the other path, and it needs a machine with UE 5.7 installed. Open the game's .uproject, let the editor compile the module, do the one-time editor wiring its README describes (a map, a widget Blueprint, importing Art/ into /Game/Art/), and package from the editor or with RunUAT BuildCookRun. Each game's README carries the exact command lines for Mac, Win64, and Android.
Run make test from the repo root before you push anything. That is the whole gate: four suites, a few seconds, no runner to wait on.
tools/make_art.py draws every card, chip, and table background in the repo and writes them into each game's Art/ folder. Pillow is the only dependency. The card faces, uno deck, chips, and felts are all generated geometry, so rerunning the script reproduces the whole set and tweaking a color there updates every game at once.