I just invented 16 new pieces (observation)

A Knight can leap from h1 to g3 and it doesn't matter if g2 and h2 are vacant or occupied.
A Xiangqi Knight however, can only step from h1 to g3 if h2 is vacant.
There's a variant Superchess with a piece Magician, and that piece can do a Knight's move only if both g2 and h2 are vacant.

Then we have the Knightrider, it can move from h1 to f5, but it cannot leap over g3 if g3 isn't vacant. That's only because g3 is one of its landing squares.

So if we were inventing a piece that could step from a1 to c4, there are 4 squares in between. For each of these 4 squares, we can or cannot make it conditional that they are vacant, for the move a1-c4 to be legal. That's how I concluded that one could invent 2 * 2 * 2 * 2 = 16 almost similar pieces.

How often does it happen that, like with the Knight and Xiangqi Knight, pieces move the same but are different in how other squares must be vacant?

İdk but if the a1-c4 leaper that isnt restricted is called zebra

Since I was thinking about implementing Superchess Magician and Xiangqi Knight myself, I hope @HGMuller can comment. How many variant pieces exist with no more differences than of this nature? How is this configured in variant engines?

No one knows

…

Leaps that can be blocked are known as 'lame leaps', and pieces having only such moves as 'lame leapers'. The best known are the variants of the Knight: the well known Horse from Xiangqi (Chinese: 'Mao'), and the variants based on it: Moa and Moo. The Moa can be blocked on the diagonally adjacent squares, but the Moo is a 'multi-path lame leaper', which combines the moves of the Mao and the Moa. I've never seen a name for the piece that could be blocked by a single blocker either on the orthogonal or the diagonal square. But in Superchess the Archer has this moves (amongst others), and is a better example than the Mage (which has additional properties).

By considering multi-path the number of pieces that move to Zebra destinations and touch only the squares you indicated would actually be 2^16 - 1.

The Elephant in Janggi (Korean Chess) is one of your 16 pieces, which first steps orthogonally, and then 2x diagonally outward.

There is a piece called Falcon (from the once-patented variant Falcon Chess) which combines the moves of a multi-path Camel and multi-path Zebra, each travelling through any of the three geometrically shortest paths consisting of three King steps.

I once read about 'Fat Pawns', which could not squeeze themselves between two occupied squares for capturing. This could be described as a multipath bent lame capture, sideway and then forward, or forward and then sideway.

As for configuring variant engines: in Fairy-Max moves can consist of two 'legs', with different 'rights' and direction. This can handle moves blockable on a single square, by first leaping to that square with move-only rights, and then leap to the destination. That is good enough for the Mao.

I think Sjaak II can handle some forms of lameness too, but I don't know which or how.

The Interactive Diagram accepts moves in XBetza notation. This allows specification of moves with arbitrarily many legs, by chaining King steps with a specified relative direction w.r.t. the previous step. That way you can define any path that the piece should follow to its destination (and where it thus can be blocked by a single blocker).

How exactly do you come to 2^16 - 1 here?

I assumed that one could make a compound of some of the 16 new pieces you just invented, where each of those 16 could or could not be included. And the -1 is to exclude that none would be included, as such a piece would have no moves at all, and thus not be able to move to the Zebra destinations.

But on second thought this is wrong, because some of the moves would be entirely included in the other, and combining those would give no extra possibilities compared to the least restrictive one. In particular the pure Zebra is upward compatible with any other.

Wait

Alpha zero can play any variant

I wish it was open source

There is an open-source version of Alpha Zero, called Leela (Chess) Zero.

But of course it cannot really play any variant. The claim that Alpha Zero could do this should be taken to mean that the algorithm it uses could also be applied to other variants. But it would be necessary to configure the program for that variant, which for most variants would require some programming effort to teach it the rules.

This is the reason that there are two versions of Leela Zero: one to play orthodox Chess, the other to play Go. These have different (but related) source code, as the rules for Go are quire different from those of Chess.

This situation is not all that different from what exists with 'classical' chess engines. These can play any variant too. Provided you change their code to generate moves according to the rules for that variant. The Fairy Stockfish project is an example of that.

A nasty thing about Alpha/Leela Zero is that you not only have to reconfiguer and partly rewrite it for handling a new variant, but that you then also have to train it. Which can take many years of CPU time.