Ratings & Comments

With my supply of pieces dwindling, I'll need these. Thanks! :)

The author, Kevin Pacey, has updated this page.

The author, Kevin Pacey, has updated this page.

@ Bn Em:

I edited the intro sections slightly, to the (3) Rules pages (two already published, recently), as I think you requested.

Appeared in 4 Double-Acts Chess.

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

The author, Florin Lupusoru, has updated this page.

I've also had the Linebacker Pawn, and the Left and Right End Pawns (those two haven't been in PotD yet, but they are described in Dealer's Chess). I know CwDA doesn't generally change around its Pawns, but they're something to look at.

I've also been toying with a couple of other ideas for American football-inspired pieces.

I think, too, that I'd rather call these the Gridiron Gamers. If you're going to put my name on it, I'd rather it was some of my sillier ideas like the Gerfod, the Springer, and the Portable Hole (not necessarily those specifically, but ones like them).

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