Ratings & Comments

It appears from the Game Courier Preset that the answer is that the Long Leaper is not Captured in this situation and that only the Cannon Pawn is Captured. I suppose that I will accept this as the correct rule for now even though I don't know if this is intentional or a bug.

I don't think it's bugged. "P a6-a8;L-a8" seems to allow the Cannon Pawn to promote.

I made a change to the following functions that can run lambda functions on array values: aggregate, allfalse, nonetrue, alltrue, anyfalse, anytrue, any. These will now have access to the variable key, which will contain the key of the array value currently passed to the lambda function. This should be accessed with the var keyword to make sure that a previously defined variable is not being used.

To prevent expressions using these from changing the value of a previous variable called key, I had to raise the scope of every expression. But to get this to work, I had to rewrite each built-in function that exited the PHP function for evaluating expressions with a return. Instead of using return, I had each one set $output to a single element array with the return value, and I set $input to an empty array so that the condition on the while loop would be false. Doing this makes sure that it decrements the scope before exiting the function.

Raising the scope of an expression also makes sure that the mechanism for adding named variables to a function cannot be used in an expression to set a variable that lasts beyond the expression. The following code prints 6468, then it prints 63. This is because it raises the scope for the assignments in the expression, and when it completes the expression, it closes that scope.

set o 9;
set y 7;
set pp * var o var y =o 98 =y 66;
echo #pp;
print * #o #y;

The changes to Game Courier I described here were for the purpose of writing a checked function that would do the same job as the checked subroutine but even faster. This is for the sake of illustrating the gains in speed of using functions rather than subroutines when a function will do the job. Here's the code for the subroutine and the function:

sub checked king:
    my from piece;
    local movetype;

    set movetype CHECK;
    if isupper cond empty var king $moved space var king:
        def enemies onlylower;
    else:
        def enemies onlyupper;
    endif;
    for (from piece) fn enemies:
        if fn const alias #piece #from var king:
            return #from;
        endif;
    next;
    return false;
endsub;

def checked anytrue lambda (fn const alias #0 var key var king) 
cond isupper cond empty var king $moved space var king (onlylower) (onlyupper) 
=movetype CHECK 
=king;

I have tested the function out in Ultima, because its stalemated subroutine is not widely used in other presets, and its piece functions make use of the movetype value to determine whether it is a regular move or a checking move. Things appear to be working in Ultima. In speed tests comparing 1000 repetitions of each, the function is around twice as fast. In these results, the first, third, and fifth are the subroutine, and the second, fourth, and sixth are the function.

Elapsed time: 0.92847084999084 seconds

Elapsed time: 0.45569705963135 seconds

Elapsed time: 0.87418103218079 seconds

Elapsed time: 0.46827101707458 seconds

Elapsed time: 1.1367251873016 seconds

Elapsed time: 0.65254402160645 seconds

I asked David Howe about the situation where a Chameleon can capture a Cannon Pawn by hopping over an enemy Long Leaper, and he says "The Long Leaper is not captured. The Long Leaper capturing move requires moving to a vacant square."

I believe it does not. I only set it up; H.G. will know how that functions. Logically, it should apply to anything but rifle captures (and Ghosts and Reapers [I think you meant Vampire here] would be immune), but I'm not sure how to set that up.

Well, if you mean that the contagion applies to anything but rifle/locust captures, then the diagram has you covered already (this is logically equivalent to it applying only to capture that stop on the victim square). In the current ID setup, the pieces that have rifle/locust captures (Vampire, Ghost, and Hangman) only transform when they stop on the Zombie Pawn's square.

This can be made a little clearer in the Zombie Pawn's description, but that is really simple. Just add the underlined text at the spot it appears in.

Zombie Pawn: Moves (with capture) one space directly or diagonally forward, or moves without capture one space directly behind. Any piece that captures it and stops on its square immediately becomes a Zombie Pawn (but doesn't change color).

What further kinks are with the Vulture?

I guess the Vulture's move description isn't too problematic, except that the ID move does not match up with it. It should be mHnFXnNY.

I was thinking of splitting the checked function into separate checked-real and checked-potential functions, but as I was looking into which would be which, it looked like there was never any time when it was passed an empty space after the King just moved. In the Pre-Move sections, kpos or Kpos would be updated before calling the function, and in stalemated, it would check whether the King was the moving piece and pass the King's new position if it was. This meant I could reduce the function to this:

def checked anytrue lambda (fn const alias #0 var key var king) 
cond isupper space var king (onlylower) (onlyupper) 
=movetype CHECK 
=king;

Just in case, I ran this code in Ultima as a test:

sub checked king:
  my from piece;
  local movetype;

  set movetype CHECK;
  if empty var king:
    die "The King space at {#king} is empty.";
  endif;
  if isupper cond empty var king $moved space var king:
    def enemies onlylower;
  else:
    def enemies onlyupper;
  endif;
  for (from piece) fn enemies:
    if fn const alias #piece #from var king:
      return #from;
    endif;
  next;
  return false;
endsub;
def checked sub checked #0;

This code would exit right away with an error message if the subroutine, which was called by the function here, got passed an empty space. I then looked at completed games using the same include file, and they did not exit with the error message. So, I got rid of this code and modified the function, tested Ultima again, and it still worked for both actual checks and for moves that would move the King into check.

With that change made, I ran the speed tests again and got these results:

Elapsed time: 1.0438919067383 seconds

Elapsed time: 0.46452307701111 seconds

Elapsed time: 1.013090133667 seconds

Elapsed time: 0.48957395553589 seconds

Elapsed time: 1.1313791275024 seconds

Elapsed time: 0.49660110473633 seconds

In each pair the subroutine is first, and the function is second, and in each case the function takes less than half the time. In both this case and the previous one, these tests were done on the opening position in Chess, in which the King is not in check, meaning that it checks for check from every enemy piece without exiting early.

I think you have Missed my previous comment here, HG!

I was out of town for the computer-chess tournament in Zundert.

I don't know how to say that the source piece cannot hop to move, to capture, or capture said type. Meaning both ? and $.

I am not sure what you are asking. If you cannot hop to move or capture, you cannot hop at all, right?

$ indicates you can neither hop over, nor capture said type. If you can capture, but not hop, it would be indicated by ^. It is not possible in general to specify multiple effects for the same piece-combination in the captureMatrix, and in most cases this would not be meaningful anyway. (E.g. it makes no sense to specify what you promote to is the capture is forbidden.) The hop ban is special in this respect, as it does not refer to the occupant of the destination square, so that the move can involve 3 piece types. To cover the case of the Korean Cannon I introduced the $ symbol.

Would it be a good idea to add this to global.css?

I think it would be good to have no background color at all for <tr> elements. I see no legitimate use for it. If it is desirable to see the background color of the page for <table>, <tr> or <td> elements, they could simply be transparent. Then the page background would shine through. If it is desirable to have a color for table cells that is different from the page background, then this should be specified for the <table>  element, and the <tr> and <td> cells can be transparent to show that color in every cell. This way it is prevented that background colors of a foreground element would cover/hide non-default changes made in the elements behind it.

I guess that 'inherit' is not a sensible setting for elements like <td> and <tr>, which always have a <table> as (grand-)parent element. Because these would automatically get the color of the parent by being transparent. Inheriting the color just causes problems by eclipsing any background-image of the parenet element; it allows the background-color of the parent to sneak in front of its background-image.

In the I.D. I made the cells transparent by specifying an empty string for lightShade and darkShade. This worked, but I don't know if it is the official method (and thus whether it will always keep working). I now learned that in general (semi-)transparency can be set in HTML by using a notation

rgb(R G B / A%)

where A is the opacity (100 = opaque, 0 = fully transparant). Perhaps I should make the Diagram script recognize the empty string as a color spec for the square shades, and replace it by rgb(0 0 0 / 0%).

Maybe it is better if I explain what I want to do.

So there are these two pieces (in position 12 and 13):

  lightcannon:X:mRcpR:cannon:a4,n4,,a11,n11
  heavycannon:Y:pRpafcpR:warmachine:a2,n2,,a13,n13

The rule I want to implement is that heavy cannons cannot jump, be jumped, captured or be captured by other cannons. My captureMatrix looks like this:

  captureMatrix=////////////11$$./11$$./

but probably I got it wrong.

Note the heavy cannon is a bit more than a korean cannon is as it can jump two platforms in order capture, but not move.

can you castle through attacked square if you still have another king

Rocket, which is square interpretation of Zip on cluster cell in Rocket Chess, which is mentioned earlier, moves as following:

In other words: forward Rook, forward sidemost Zip, backward narrow Electrician.

Otherwise it has a simpler version which is forward Rook, backward Bishop and forward sidemost Nightrider:

Zombie Pawn: Moves (with capture) one space directly or diagonally forward, or moves without capture one space directly behind. Any piece that captures it and stops on its square immediately becomes a Zombie Pawn (but doesn't change color).

I clarified this, essentially the same way but expanding a bit more.

I'd love to make the Reaper and Mummy also immune, and there's probably some way of doing that, but I'm not sure what. If there is, maybe H.G. can chime in to help.

I guess the Vulture's move description isn't too problematic, except that the ID move does not match up with it. It should be mHnFXnNY.

Well, that's definitely a "kink." I think I miscounted or something. I changed the ID move as indicated.

I think the piece is an invention of Lev's; if it's the description that should've been changed, hopefully he'll speak up.

Aand you've rederived these pieces as a back‐formation ;‌) These are the original (long‐ and short‐, respectively) non‐helical switchback rhinos as proposed by Gilman (and independently by KelvinFox).

Actually never mind, these are two of Gilman's four: Long‐switchback Rhino and Short‐switchback Mirror Rhino. The other two move the same but with the non‐alternating step first.

Note incidentally that Gilman's ‘rhino’ is this one (specifically the sliding version), not the (modified) GA one as popularised by Jean‐Louis (hence why both forms are referred to by that name). The fact that both begin W‐then‐F is coïncidence

Also (belated) Happy Birthday :‌)

The first position in each row is for the non-capture. So if the Cannons are number  12 and 13 in the table, the Cannon x Cannon indications would need to be in the 13th and 14th element of the row. So 12 'nothing special' positions in front of them.

There is no row for empty squares, as empty squares cannot be moved. So you would have to specify this in the 12th and 13th row of the matrix. But it seems you are doing it in the 13th and 14th.

I think the [vulture] is an invention of Lev's

I thought it was from Aurelian's Grand Apothecary Chesses?

This seems like a really cool idea from the late Problemist

As far as admin is concerned, I assume it desirable to have a link to this as Kazan Chess (the original name), and to credit Grolman as the inventor? Since it looks like you've done a bit of filling in the details, it's at your discretion whether you wish to take coïnvention credit.

Since it originates as a problem theme, two further questions arise:

• How does it actually play as a game? I imagine it's very different in flavour from Orthochess but I wonder whether it might tend to be a bit chaotic.
• Would it be worth including a problem or two on this page? I don't know if there would be copyright issues with including the original 1995 Problemist composition, but your Mate in 2 is pleasantly illustrative

I imagine there are more interesting ways to resolve the Castling issue than simply disallowing it outright (other pieces either have to fill both vacated squares where possible, or just the king's one as Castling seems to be a K move by problem convention (see the discussion of Half‐Neutral pieces in the same Problemist issue), and we could consider a K or R unmoved if it has only moved involuntarily), but this solution works too

I thought it was from Aurelian's Grand Apothecary Chesses?

It could well be. My memory, as I've stated many times, is pretty wretched.

Also (belated) Happy Birthday :‌)

Thanks! :)

Lovely