SlopfishAlpha
A combo solver for Yu-Gi-Oh!

Name the board. It finds the line.

Give Slopfish a deck, an opening hand and the end board you want. It searches the legal plays from that hand and hands back a line you can step through one move at a time, on a board with the real cards on it.

The Slopfish replay viewer: Kashtira's Arise-Heart board at the bottom, Onomat building Xyz Monsters at the top, mid-turn on turn two.
A recorded game in the replay viewer. Kashtira went first; this is Onomat's turn two, 27 steps in.
What it does

Three things, in order

Finds a line to a board you name

You pick the target, such as three named bosses with their materials. There are no hand-written combos inside: the solver works from the cards' own effects, so it also finds lines nobody taught it.

Plays into the other side

One deck builds on turn one. The other draws for turn and tries to play through that board, with the first player's negates and hand traps answering along the way.

Shows you every step

Each game is saved as a replay. Scrub through it, read any card, open the Graveyard, and see the full list of legal moves at any step with the one it chose marked.

How it works

The printed card is the specification

A solver is only worth trusting if its rules are right. Most of the work in this project is about that, and very little of it is about search.

  • 01
    Cards are written as declarationsAn effect is a cost, a target and a list of steps taken from one shared vocabulary: draw, banish, attach, Special Summon. A new card mostly reuses steps that other cards already proved.
  • 02
    Rulings are fetched, then citedWhere a card's text leaves a question open, the answer comes from Konami's own rulings database and is stored beside the card with its source.
  • 03
    A hand solved in under a minuteIt works through millions of possible positions for a single hand, 5.2 million for the line beside this, keeping the most promising at every step until it reaches the board.
One real line, every step · Onomatopaira + Gagaga Ganbara Knight
 1. Onomatopaira: pitch Gagaga Ganbara Knight,
    add Gogogo Goblindbergh, Zubababancho Gagagacoat
 2. Normal Summon Gogogo Goblindbergh -> SS Onomatokage from deck
 3. Xyz Summon Gagagaga Girl using Gogogo Goblindbergh, Onomatokage
 4. SS Zubababancho Gagagacoat from hand
 5. Gagagaga Girl: detach 1 (Gogogo Goblindbergh), add Unbreakable Xyz Barrier
      -> search Dododo monster: Dodododo Warrior
 6. Gagagacoat: revive Gogogo Goblindbergh from GY
 7. Xyz Summon Gagagaga Magician using Zubababancho Gagagacoat, Gogogo Goblindbergh
 8. Gagagaga Girl (granted): Utopic Future can make a second attack each Battle Phase
 9. Xyz Summon Number F0: Utopic Future using Gagagaga Girl, Gagagaga Magician
10. Gagagaga Girl (granted): Utopic Draco Future can make a second attack each Battle Phase
11. Utopic Future -> Utopic Draco Future (3 materials)
12. SS Dodododo Warrior as Level 4 (sent Dodododwarf Gogogoglove to GY)
13. SS Onomatokage from GY
14. SS Dodododwarf Gogogoglove from GY
15. Xyz Summon Infernal Flame Banshee using Dodododo Warrior, Onomatokage
16. Banshee: detach 1 (Dodododo Warrior), add Agnimal Candle
      -> search Zubaba monster: Zubababancho Gagagacoat
17. SS Agnimal Candle (added by effect)
18. Gogogoglove: SS Zubababancho Gagagacoat from hand
19. Xyz Summon ZS - Utopic Sage using Dodododwarf Gogogoglove, Agnimal Candle
20. Utopic Sage: detach 2, SS ZS - Ascended Sage from Deck
21. Xyz Summon Number F0: Utopic Future Zexal using Infernal Flame Banshee, ZS - Utopic Sage
22. Xyz Summon Number 39: Utopia using Zubababancho Gagagacoat, ZS - Ascended Sage
      -> search Rank-Up-Magic Normal Spell: Hyper Rank-Up-Magic Utopiforce
23. Utopia -> Utopia Prime (3 materials)
24. Utopiforce: Utopia Prime -> Number 99: Utopia Dragonar (4 materials)

END BOARD
  Number 99: Utopia Dragonar        4 materials
  Number F0: Utopic Draco Future    3 materials
  Number F0: Utopic Future Zexal    2 materials
Under the hood

Every position, at once

Most card-game engines apply one move to one board. This one never looks at a single board. Every position the search is holding lives in memory as one block of numbers, and each rule of the game is written to act on all of them together.

What one step of the search looks like
positions   [ boards x 132 ]      one row per board in hand,
                                  132 numbers describe each
legal?      [ boards x moves ]    one yes or no per board,
                                  per move, in one pass
apply       gather, write         every chosen move is played
                                  on its own copy, all together
merge       hash                  boards reached by different
                                  move orders collapse into one
keep        the most promising    and the step repeats
  • A
    No loop over boardsAn Xyz Summon, a detach, a Chain Link or a negate is written once, as array arithmetic that answers "on which of these boards is this legal, and what does each look like afterwards?" for all of them in a single operation.
  • B
    Cards become rows in tablesA card file is data. Its costs, targets and steps compile into rows of the shared tables those operations read, so a new card adds rows, not a new code path.
  • C
    The same board is never paid for twiceTwo move orders that reach the same position are recognised by a fingerprint of the whole board and merged, which is what keeps a 24-step combo searchable.
About

Why this exists

The engine's origins come from a recognizable place: looking at a complex rank 4 slop hand and wondering whether or not you misplayed. From those simple beginnings, the project of creating a perfectly generic yugioh hand solver naturally followed, and it also follows that there should be some way of knowing whether or not your end board is also misplaying.

Slopfish seeks to bridge that gap. With this tool, we aim to fulfil these two goals fairly accurately in an engaging way. Downstream from just the solver, intended to be present are a deckbuilder, an optimizer, and a way to test hands against the algorithm yourself; all of these are trivial to develop once we've built the underlying system, so we thought "why not?".

Turns out building the underlying system though is a nightmare. But, at the same time, a fun nightmare, and a nightmare that I hope you all get to try for yourselves very soon.

The team, and getting in

Who makes it

Made by a couple people who just wanted to see a cool tool exist, Slopfish is made by a small but dedicated team. Fueled by curiosity, a need to optimize, and of course the desire to see what the community can do with this kind of promethean fire, we hope you're as excited about the idea behind Slopfish as we are.

Availability during this stage of development is extremely limited, but if you have a convincing enough use case we'd love to hear about it. Less of a wait list and more of a "I'll get back to you", for a brief while longer, unless you're a competitive circuit player, you'll be holding on for just a bit more. If you are a competitive circuit player and willing to review lines and give feedback, you're welcome to try out the tool.