Comments/Ratings for a Single Item

I wanted to reserve @ as atom for indicating dropping. Single or double quote behind a modifier was proposed for friend-only or foe-only (e.g. on p). For grouping of atoms I would use braces {} rather than overloading the parentheses. But  I like the double-quote idea better (except that I would use &, as I thend to interpret quotes as suffixes of the previous symbol), as meaning 'same group of modifiers as previously'. I don't think that would be very useful in the bracket notation, though, as there will never be very many modifiers on an atom there. And perhaps it is more useful to focus on a full implementation of the bracket notation than trying to keep the a notation bearable through all kind of quirky tricks.

And one can also look at it this way: an unwieldly Betza notation is a very useful 'red flag' to indicate you are attempting to do something that you really should not do. The complexity of Betza notation reflects the complexity of conceiving the moves when playing, and perhaps that is a good thing.

I was thinking of something like dabaubR where each successive leg should not be longer than the previous.

If I understand this correctly that means a Rook that relocates the friendly piece at the end of its extrapolated move to any of the squares it passed over. Requiring a certain order of the intermediate 'transition squares' is difficult for back-and-forth movement, but comes automatic when you always move in the same direction. E.g. the Valkyrie in Odin's Rune Chess is basically a simplified version of what you use here, which can ony relocate a piece on its destination. Rather than first picking off the piece, and then moving back to the point where you want to unload it, (which would require length restrictions to not overshoot the origin), I described it as first moving to the unload square, and then continuing to the target ([Q-udQ] or  afudQ). That automatically guarantees the unload is between origin and destination.

So in the case you describe you could at least first move to the unload square. Unfortunately there is no such freedom for the destination; this always has to come last. So you would get an m slide to the unload square, fud slide to the piece that should be relocated, and then an m slide back to the destination. The 3rd leg should be shorter than the 2nd, which you can enforce by making the last leg an i leg, and split the 2nd leg into two: [Q-uQ-dQ-ibQ] or afuafdaibQ. Another way to look at that is traveling origin - unload - destination in the same direction (to enforce the order), followed by a friendly rifle capture in that same direction.

(I think that this is what Bob had in mind too, but he wrote the u in the wrong place.)

I found an interesting method of applying a on the wikipedia page of Ko Shogi, where for example a4 means "up to 4 times", thus KaKaaK would be rewritten as a3K. You could also add an ! to indicate that it must use that exact amount of step, no more, no less. a!5W indicates exactly 5 Wazir moves
Note : In the context of Ko Shogi these multi-steps are allowed to capture a piece on every step, maybe we should do ac3 or another punctuation to indicate multi-capture or something else. This also means that a1 has no definition and a is a2. Edit: The new a, if it were to be defined as a2, would be defined as a combination of the old a and non-a move, which may be weird and or difficult to implement. The old a would be a!2

With this aa is opened up and i think a good idea for what it should be is "as many times as you want", based off the doubling of leaper atoms, which gives us the notation of the Dabbabante and the Ubi-Ubi, being aaD and aaN respectively

You can already shorten KaKaaK though by 1 character by writing (a)2K. Dabbabante is (mpaf)D.

Well, what you propose is not backward compatible with what we have, so that rules it out no matter what. I think repetition through parentheses is more flexible than on individual modifiers, and can achieve the same thing. KaKaaK can already be written as (a)2K, and if all steps should capture as c(ac)2K, or (ca)2K if the last step does not have to capture. Exactly 5 Wazir moves can simply be written out in full aaaaaW. The Ubi Ubi can already be written as (a)N.

But I want to get rid of the a notation (which was the core of XBetza), which quickly gets very obscure. And the need to express everything with a single atom is often very cumbersome, requiring many mp intermediate steps for what really is a single (but incommensurate) leap. The bracket notation, which is somewhat similar to a very old proposal that I called Betza 2.0, would solve all that. But I never think there was any formal specification of it, which should be a first step. So:

Betza 2.1

All extensions of XBetza apply, except that the a modifier is not used for chaining, y does not exist, and g exists only as legacy from original Betza notation (i.e. in a single-leg move describing a grasshop).

Complex moves must be surrounded by brackets [ ]. Within the brackets there can be a number of simple Betza move descriptors, each describing a leg of the move. These can be separated by hyphens - or question marks ? . The meaning of a question mark is defined as

[A?B] = [A][A-B]

The hyphen indicates chaining: the legs must all be made one after the other, the next one starting where the previous one ended, each satisfying the conditions that their Betza notation specifies. The default mode for non-final legs is m. This doesn't exclude the leg descriptions from being compounds:

[A-BC-D] = [A-B-D][A-C-D]

Directional modifiers in continuation legs are interpreted relative to the preceding leg, where f is default, and means "as much in the same direction as possible". Since legs need not use compatible atoms, it is not completely trivial what that means. So to be more specific:

• Diagonal after diagonal and orthogonal after orthogonal: f = exactly the same direction (W system).
• Diagonal after orthogonal and orthogonal after diagonal: f = two moves, deflecting 45 degrees (F system).
• Orthogonal after oblique: f = in the direction of the longest orthogonal component (W system).
• Diagonal after oblique: f = in the same quadrant (W system).
• oblique after diagonal: f = two moves in the same quadrant (N system).
• oblique after orthogonal: f = two moves closest to that orthogonal axis (N system).
• Oblique after oblique: f = in the same octant (K system).

The use of an 8-fold radial (pseudo-)atom like K or Q after oblique might result in undefined behavior, unless all directions are allowed. After diagonal or orthogonal atoms these use the K system, with f is in exactly the same direction.

In this system a is a new directional modifier for use in continuation legs, meaning "all directions, except to squares that were already visited earlier in the path". And 'the path' is supposed to also contain the square of origin.

The bracket notation always specifies completely (i.e. 4-fold or 8-fold) symmetric sets of moves. If the use of compound legs allows non-congruent paths, each such path will be included in all its orientations (including reflections). That means directional modifiers on the first leg are not allowed. To define a subset of these moves, directional modifiers should be placed before the brackets.

Paths that completely stay on one diagonal or one orthogonal will be considered of that symmetry; other paths are considered oblique. Directional modifiers in front of the brackets will be interpreted in the symmetry class of the trajectory that is subject to it. For oblique moves the direction in which the path first steps of an orthogonal or diagonal determines in which of the two adjacent octants it belongs. E.g. for a Ship, the symmetric move set is that of a Griffon ([F?R]), and the first oblique squares on its allowed paths are that of the narrow Knight (vN). The Ship is thus v[F?R].

Consequence: describing trajectories of different symmetry in one bracket notation can be asking for trouble if you want to make a selection. If you write fr[R?sR] the brackets describe both orthogonal and oblique moves. For the Rook moves fr means forward or right, but for the hook move it means the forward one of the rightmost pair, which would be first right and then forward.

Prentheses can be used to indicate the text they enclose can occur zero or more times; a number behind the closing parentheses indicates the maximum number. E.g. [(pR-)cR] is a Rook move that must capture, but can hop over arbitrarily many occupied squares to do so.

Burning: trajectories of 'flames' can be appended as extra leg(s) within the brackets, separated from the real move by a semicolon ; rather than a hyphen. The piece would in any case end up in the destination specified by the last leg before the semicolon (to which the rules for a final leg apply). From there any valid move of the burning spec (interpreted as continuation legs of the move, as far as directional modifiers and i legs go) would then burn its destination. E.g. [Q;cK] would be an Advancer, burning the square just beyond the one where it stopped, [Q;acdK] would burn all pieces (friend and foe) adjacent to the destination, [Q;ibQ-cK] would be a Withdrawer, and [R;ap'D-bcW] would be an Ultima Pincher Pawn if p' indicated friendly hopping.

Planar moves: (proposal) these could be indicated by two moves within brackets separated by a period. The meaning of [A.B] would be that any move consisting of zero or more repetitions of a move described by A and a move described by B would be valid if any move with a smaller number of such repetitions of A and/or B would end on an empty square.

I think that's a good use of @, ', and ", and your note about quotes looking like suffixes is a part of why I prefer | for the "or" function -- & would be (or at least look like) more of an "and" function, like trying to make an alternative to bracket notation.

And consider my Grandmaster Mage, currently notated as ooKooCooZooudcKooudcCooudcZaooxKaooxCaooxZ. (I probably can delete the first triad, perhaps with an m in t he second, and the last one may need another oo, but that's irrelevant here.) It would be much shorter with (treating the other string as though it's correct) ooK|C|ZooudcK|C|ZaooxK|C|Z, which is less than half as long.

A thought on ' and " on p (and presumably g): Doing this would still leave those marks open for similar but different meanings ono other modifiers. I have no ideas on what such meanings could be; I just thought I'd point that out.

Aside: Long-term, I'd like to eventually see ! used as an atom suffix for "not when under attack," and !! for "only when under attack." But that's admittedly a fairly low priority, since at this time the Chicken Pawn is the only piece I'm aware of that would use it (maybe the Anti-King and/or Orphan).

Dabbabante is (mpaf)D.

Thanks for that! I was trying to figure it out a while back, and here's the very obvious solution.

I wonder what (mpaf)A would be. Elephante? Then (mpaf)S could be Alibabante....

I think that this is an excellent documentation for full bracket notation, but for two or three quibbles.

One is a typo: in the paragraph on Burning, you say "color" instead of (the first time of) "colon." Also, I'd wonder whether directly backwards is part of the default, or would have to be added.

Second, while that's a dead-on explanation of a as used in this context. I think it's worth mentioning that a(b) or ab can be used for any direction including exactly backwards. (My experience is that for former works, but not the latter.)

About planar moves: This needs a clearer explanation of what a planar move is. Besides being convoluted (for brevity, no doubt; "Hello, Mr. Kettle"), the description there doesn't match up with the explanation that I recall being given to me. Also, this might be a better use of & (as referred to in another Comment) as being both more visible and (arguably) more intuitive than ..

PS: The Ubi-Ubi as (a)N is pretty simple, though it does seem to overwhelm the system (at least, on my computer, which is particularly powerful).

(I think that this is what Bob had in mind too, but he wrote the u in the wrong place.)

Guilty on both counts! :)

Something just occurred to me about punctuation in the notation. How would : (for burn moves) interact with the use of colons in Interactive Diagram coding?

Ughh, that would be a problem indeed. Better use a semicolon for the burning then.

Also, I'd wonder whether directly backwards is part of the default, or would have to be added.

Good question. It makes less sense to exclude it here. OTOH, normally this square has to be empty, or it would have blocked the move. So it only becomes an issue for a burning Grasshopper move. As it seems quite unlikely anyone would use that, there seems little harm in excluding it. Just for uniformity with other continuation legs. It is easy enough to add it through ab, while it would be very hard to exclude it.

the description there doesn't match up with the explanation that I recall being given to me.

Well, I tried to generalize it. But I think I blew it, because I was thinking in terms of steps rather than moves when I wrote it.For the conventional 'orthogonal planar move', which we would write here as [vR.sR], the point is that the steps set up a grid (in this case containing every board square), and that you only have to consider what is on that grid. But (on an empty board) every square of the grid could be reached by zero-or-one move of the first kind plus zero-or-one move of the second kind. The area spanned by the move (which must be empty) consists of all squares that could be reached by fewer or shorter moves of both kinds.

I used the dot because I saw it as a multiplication. A comma could also be suitable, if you see it as coordinates.

The Ubi-Ubi is of course a sick piece. The problem is that the current implementation of the I.D. tabulates each angular realization of a given move, and for multi-leg moves that can freely change direction that quickly explodes. Even the Tenjiku area move, (a)2K, produces some 500 trajectories.

Good question. It makes less sense to exclude it here. OTOH, normally this square has to be empty, or it would have blocked the move.

Not if the move is a leap. Imagine, for example, a Flame-ingo with [CX;KD].Or, probably more to point, a piece with K[T;K] -- or should that be K[T;abK]?

Well, I tried to generalize it. But I think I blew it, because I was thinking in terms of steps rather than moves when I wrote it.For the conventional 'orthogonal planar move', which we would write here as [vR.sR], the point is that the steps set up a grid (in this case containing every board square), and that you only have to consider what is on that grid. But (on an empty board) every square of the grid could be reached by zero-or-one move of the first kind plus zero-or-one move of the second kind. The area spanned by the move (which must be empty) consists of all squares that could be reached by fewer or shorter moves of both kinds.

Yeah, I was thinking Rook/Bishop when I was reading it, not Wazir/Ferz. This explanation is much better, and reflects what I recall.

I used the dot because I saw it as a multiplication. A comma could also be suitable, if you see it as coordinates.

I'm actually seeing the planar move as a simultaneous two-way move; that's why I was suggesting the ampersand. (Another symbol that makes sense to my brain is the slash -- though it's also one that I think would probably confuse the computer!)

Not if the move is a leap. Imagine, for example, a Flame-ingo with [CX;KD].Or, probably more to point, a piece with K[T;K] -- or should that be K[T;abK]?

In the former the burn would go to all 12 squares, as none of the KD steps is perfectly aligned with CX. In the second case one of the moves would go exactly in the backward direction. Although it doesn't seem a disaster having to write ab, I guess it shows that there really is no reaason to forbid moves with another stride. So I will change the definition to that it should not go back to the previously visited square on the path.

That reminds me that in XBetza at some point I defined it as not being allowed to return to any previously visited square, to prevent that aaK could make a turn pass by triangulating. Of course this was pretty much unimplementable. Now as the Ubi-Ubi (which basically has an unlimited-range area move with Knight steps) shows, area moves really need a dedicated generator if you want to treat those efficiently. (As is very important for the AI.) There is just too much overlap between them. (a)2K has 456 possible realizations, but these reach only 49 squares. So each move is generated some 9 times on average. A good algorithm would be to tabulate first which squares you can reach in one step, and then from all of those take another step to tabulate those you can reach in two steps, eliminating duplicats at every stage.

-King can't castle when in check in Chess

-King may not move out of check, except to capture its singular attacker in Makpong would be something like !mKcK

-Vaulting Camel-King from fairy chess problems would be K!!C

-Transmuting King from fairy chess problems (King but when it is threatened, moves only like the threatening unit(s) (!K+Orphan))

-Tengu pieces from MAD Chess

-etc.

I am not sure that rules like this would qualify as being part of the move. Betza notation is supposed to describe the pseudo-legal moves of a piece, and that some of those might be forbidden in a real position because of the constellation of pieces outside the path, is what makes the difference between legal and pseudo-legal moves. Moves of pieces in a variant that has a checking rule are not written differently than in a variant that hasn't.

A rule for not being allowed to move out of attack can be implemented in the AI relatively easily: you test for in the reply move whether you can capture to the evacuated square. This is how the ban on castling out of (or through) check is implemented to. The AI is not aware it is in check, but on castling it marks the King's origin and passed-through squares as 'royal' e.p. squares, and considers any capture-capable move to it in the next half-move as an (immediately winning) King capture.

Moves that are only allowed when you are attacked are much harder to implement. They are a form of enemy induction. (Which the I.D. also doesnt't implement for that reason.)

So I will change the definition to that it should not go back to the previously visited square on the path.

That, I think, would be the ideal. :)

A good algorithm would be to tabulate first which squares you can reach in one step, and then from all of those take another step to tabulate those you can reach in two steps, eliminating duplicats at every stage.

That can be great, though sometimes where a piece can move from a square depends on where it came from. With a Rose, for example, any square that can be reached in 2 or 3 steps has two ways of approaching (unless blocked), and each of those two ways has a different allowed exit -- four if the Rose is allowed to go full circle. Some complex bent sliders, the Combine being the most common, also have overlapping moves. The algorithm would be perfect for pieces like the Ubi-Ubi or Shogi area movers, and probably would also improve regular radial sliders and oblique riders (especially those with cannon, grasshop, or juggernaut moves), but there should be some way to allow for "this way in, that way out" (like ignoring the elimination of duplicates after a turn modifier is encountered).

Moves that are only allowed when you are attacked are much harder to implement. They are a form of enemy induction. (Which the I.D. also doesnt't implement for that reason.)

I actually was thinking that it could be something that the new off-site AI you mentioned being in the early stages of working on might be able to manage. And HaruNY did point out a few other cases where the rule is used.

It's something to consider, at least, as you're building said AI engine. :)

Somethings i want to note and some ideas

• gK should be able to be written as [jS?Q] but the latter moves completely different
• gQ4 i expected to be a grasshopper, not a lion, limited to 4 tiles in total, the case of up to 4 tiles after hurdle can be constructed using square brackets [gQ?Q3] (i think, doesn't work in the diagram on the page)

• h on it's own has no definition, something like relative half, from the halfling, could work
  • This does make left-only half impossible as lh and hl already have a meaning, you could use a punctuation like a comma , to seperate them so that the compound doesn't work, with this , you can make a move that's initial and non-leaping, but does not create e.p. rights i,n
• t could be used for checking if there's a piece there, adding c or d to specify enemy or ally piieces

I think a nice feature would be to allow multiple platforms for cannon like pieces. Personally as I don't like the idea of bishops in a Xiangqi or Janggi environments I'd like a pRppcR instead (where pp stands for 2 platforms). Some food for thought.

@Aurelian: What do you call "platform"? Do you mean the "screen", as defined in https://www.chessvariants.com/piececlopedia.dir/pao.html?

Bracket notation is a proposal for future improvement, and basically not implemented. A few cases representing commonly used pieces such as Griffon are recognized, and handled by a pre-processor that substitutes the corresponding a-notation. The S is apparently not amongst the recognized cases. (This might be easy to fix.)

Range limits on hoppers has always been a problem in XBetza, because you would really need two ranges: one for before, and one after the mount. The rules for range toggling (triggered by g or y) are such that the specified atom + range count for the first leg, that finite range turns into infinite, and infinite into 1. So gQ4 means up to 4 steps to the mount and infinitely many behind.

Bracket notation would solve this, by allowing you to specify a range in each leg. But it is not implemented yet.

Reusing an existing symbol has little advantage if you have to introduce a new symbol to resolve the ambiguity it causes. IIRC 'halfling' is a (flexible) range specification, so it would be more natural to indicate it as a (non-numeric) suffix than as a modifier prefix. I would suggest the % sign, as the actual range should be a fraction of the free path. We could even give different meaning to W% and R%.

As a symbol on its own checking for a piece is already done by p. If a combination of symbols is to be used for specifying whether it should be friend or foe, I'd rather use p' and p" than a t. The quotes could be used to diversify other modifiers as well. E.g. c' could be friendly capture, and c" friendly or enemy capture. Than d could be retired.

Indeed, screen = mount = platform. Two platforms you can already do by [pB-pB-cB] or pafpafcB.

gafQ3

I like that idea for the %. It's actually quite intuitive for the symbol's conventional meaning. The only question is, what effect would that have on a Rook on a rectangular board? If the board is 12x16, would the half-Rook move six spaces sideways and eight spaces vertically? (That actually would make the most sense to me.)

As for using ' and " to "retire" d, I think the letter would have to be retained for backward compatibility. Otherwise, I think we'd have freed the L and J atoms by now. (I personally would welcome seeing all three characters freed up for potential new uses -- like, an atom for Bison (CZ), mainly for use with Cheetahs, Sabertooths, and related pieces, which I wouldn't try to do with the smaller number of free atoms we have right now.)

On a (mostly) unrelated note, I'm finding trouble when I try to put more than one pair of parentheses into a move, whether nested or sequential. For an example of the latter, I've tried expanding the Springer's pya(b)K move so that it can bounce off more than one target, but pya(b)(pa)K (or even pya(b)(pa)2K) doesn't yield anything but an error message ("No atom at end").

PS: With some experimentation, I've found that shQ and shK yield "all directions except forward and backward," while vhQ and vhK yield "all directions except left and right." I just thought I'd point that out; I think it'd be worth documenting. :)