Comments/Ratings for a Single Item

I used these when I hadn't learned how to use morph
Edgehog2
oabyaK(af)mpafoabK
Edgemover
(af)mpafoabKoabyasW
(Limited) Edgehog
oabyafympafmpabFmpabasmpabafmpabasoabyafympafmpabWmpabasmpabafmpabaz(af)mpafoabK

That Limited Edgehog does exactly what we're talking about!

The sandbox doesn't seem to work with moves that involve three separate intputs, such as cabaubQ

That is true. The sandbox still uses betza.js, and only betzaNew.js can handle moves that need more than 3 clicks.

I am not sure why I haven't upgraded that yet.

Thing is, when I try it in the Sandbox, it does allow moves parallel to the edge (which you've already noted yourself).

Not for me. Except in the corner, but that is because it is then perpendicular to the other edge. But oabyafK wouldn't move from a2 to a7, like an Edge Hog should have.

[oW-bW-aQ] is translated into oabyaW, which also does allow moves parallel to the edge, as well as not allowing diagonal moves.

It does allow move along the edge because it was supposed to move along the edge: there is no f in the final leg (and an a in the bracket notation). But yes, it is wrongly translated. Bracket notation is not really supported yet by the ID. The only thing that is guaranteed to work is slider after some not-to-far leaps, to work for Griffon, Manticore and Ospray, and with some rider steps in the second leg. With more than 3 legs it is basically a coincidence if it works, especially when the legs use different atoms: XBetza is based on the use of a single atom, and the code only worries about making the atoms in the first two legs compatible.

vvssoabyaK has the same result as the first one.

Again, not for me. This one can move from a2 to a7 (as intended). It does give the correct Edge Hog moves (for an Edge Hog on an edge square). If you try that move in the Play-Test Applet and generate GAME code, you can see that the legdefs array contains only 28 moves for the Queen, so there are no duplicats. (Testing in 4 different directions, each followed by 7 different 3rd-leg continuations.) Except in a corner, where two of the test steps would go off board, and would then continue in 3 different ways each.

Of course it is still stupid: of the 7 continuations the two diagonally backwards are guaranteed to also go off board, and would always be attempted in vain. So it would be better to write vvssoabyassfhK. This limits the continuations in the 3rd leg (after orthogonally stepping back on board) to sideway (along the edge) and forward-half, 5 instead of 7. Indeed the GAME code only puts 20 moves in legdefs, for that case.

I can accept that as a line of reasoning, though it'd be much more "natural" if there was a way to enter it other than opening the raw code and typing it in by hand (which is sadly open to typos and other errors).

Well, the Play-Test Applet 2.0 allows you to do that, right?

The oflabaoslabaofly sequence I suggested was supposed to test forward left, forward right, and backward of the desired move ...

Note that a move only succeeds if all its legs meet the specified target. So what you write here only succeeds if you get off board in all directions. Which would be  the case on a 1x1 board, but there the entire test would be redundant.

what about having ii mean up to the same distance in continuations, and iii meaning at least the same distance

what about having ii mean up to the same distance in continuations, and iii meaning at least the same distance

I don't think I'd do it quite that way, but having some way to indicate this would be nice.

Do there exist pieces that need this?

It seems to me it can already be expressed by inserting an extra slider leg in the same direction for making up the difference. Like [R?fR-isR] for a hook mover limited to the forward quarter sector.

I don't think it is a good idea to invest in (and spend resources) merely simplifying cases that almost never occur.

The author, H. G. Muller, has updated this page.

Note that a move only succeeds if all its legs meet the specified target. So what you write here only succeeds if you get off board in all directions. Which would be  the case on a 1x1 board, but there the entire test would be redundant.

As I mentioned in the original paragraph, oflabaoslabaofly was erroneous; the next sentence gave an improved oabaflabalabayflK, which (theoretically) attempts to move off-board to the back, on-board front-left, and on-board front-right before sliding forward.

[R?fR-isR] for a hook mover limited to the forward quarter sector.

So, mission accomplished for the second leg being shorter than the first; [R?isR-fR] can make the second leg longer than the first. That's what I was asking about. Adding [R-isR] can make them "equal to or less/greater than." (Or, [R?fR-isR?fW] for "less than or equal to," and [W?fR?isR-fR] for "greater than or equal to.")

That's certainly good enough for me.

On an entirely different note, what do you think about inn (or perhaps ine) for "initial lame move, not subject to en passant"?

The Reflecting Bishop (for a single reflection) is yafoabyasB. To the edge, one more step back and forthe to test whether you ran into it, and then continue again as slider in the perpendicular direction. [B-oF-bF-sB] in bracket notation. I gues even [oB-bF-sB] would do (but would generate moves in duplicat when already on the edge).

I was thinking that this would be a good Case Study for the page. Also, I had the thought that (yafoabyas)4B might allow for a full rectangle on a square board (or omitting the 4 to allow unfettered reflecting on a rectangular board), but that doesn't appear to be the case.

It seems to me it can already be expressed by inserting an extra slider leg in the same direction for making up the difference.

I don't see how you can express a shorter leg like that. I was thinking of something like dabaubR where each successive leg should not be longer than the previous. The only way that seems possible now is to do every possible combination of different numbers of W steps. But you understand it all better than I do

Another idea that's probably also too unusual to matter is to allow repeated p modifiers in a single leg so i could be applied to a move that hops over multiple pieces.

I don't see how you can express a shorter leg like that. I was thinking of something like dabaubR where each successive leg should not be longer than the previous. The only way that seems possible now is to do every possible combination of different numbers of W steps. But you understand it all better than I do

I don't think dabaubR is quite what you're after; the u should come before the d, if you want your Rook-like piece to move a friendly one. What you have there would simply make the friendly one disappear, and then move any enemy piece it captures at the end to an earlier point in its move. The effect you're after there would be more like uafafdaibR -- the first move forward sets the landing spot for the other piece, the second sets the landing spot for the moving piece, the third picks up the other piece and transports it to the landing spot, and the backward move puts the moving piece at its landing spot.

(Sadly adding entirely new modifiers will be difficult, as only the letter w is still unused.)

Actually, t is also unused. (But that only helps a little.)

Aside: I like the increasing use of punctuation here. So far I can find ()[]-?*', with a proposal for :; I'm not sure what's still available, though. At least +{}"`, I'm pretty sure, and I'm guessing at least most of \|@#$%&!, should anything more be needed that punctuation would cover. (I can't think of anything right now, though when certain new things are implemented I probably will).

Addendum: After a couple of hours, I thought of something. There probably should be some way to indicate that the same set of modifiers applies to multiple atoms; that would be handy for when that's being done with especially long modifier strings and/or several atoms. The simplest might be to enclose the atoms in parentheses, though putting a pipe (| sometimes used to mean "or") or double-quote (", sometimes used as "ditto marks," meaning "same as before") could work too. So (giving a more or less random example) while a (0,1)-Zigzag Nightrider is Nabl(abz)N, doing the same with a Buffalo, which would now be NCZabl(abz)Nabl(abz)Cabl(abz)Z, it would be NCZabl(abz)(NCZ), NCZabl(abz)N|C|Z (which would be my choice), or NCZabl(abz)N"C"Z.

(I'm not expecting that next week, or anything. It's just something to ponder.)

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).