Comments by FergusDuniho

After creating this page, I moved some earlier comments on the fairychess include file to this page.

If you tell me what the image was, I can purge it from the cache sooner.

Although they don't need it, I just added the same code to Chess and Grand Chess, so that it's there if someone copies the code from one of these.

I just made some modifications to Gross Chess and the fairychess include file to use aliases for alternate piece names. Instead of the code I just showed you before, you can use this code:

alias Archbishop Cardinal;
setconst A Archbishop;
setconst a Archbishop;

But you will also have to copy some code from the Post-Move sections. The main change is that I added realname in front of const in expressions where I needed the function or subroutine name. Where I want to use the alias for display purposes, I did not use realname.

Looking at your code, you used the names of Cardinal, Marshall, and Half_Duck instead of Archbishop, Chancellor, and Lion. To use other names, you need to copy the relevant functions and variables to new names. For an example, I used this code to change the Cardinal to an Archbishop in Gross Chess:

copyfn Cardinal Archbishop;
copyfn Cardinal-Range Archbishop-Range;
set Archbishop-Desc var Cardinal-Desc;
setconst A Archbishop;
setconst a Archbishop;

Thanks, I've corrected that.

Because then it is no longer that players turn, and a Joker is not allowed to move in the opponent's turn.

That's true of every piece on the board.

So during the opponent's turn it has no powers at all.

But that's not true of other pieces. Other pieces retain checking power during the opponent's move.

I would imagine that the Joker retains whatever power it used to move until the opponent moves another piece, thereby giving it a different power of movement. For example, if the Joker moves as a Rook and checks the King, the King would be in check, and one way to remove that check would be to move a Bishop, which would change the Joker's powers of movement.

The rule is that the joker moves like the last move of the opponent.

As stated, that's too ambiguous. Here are some possible interpretations:

1. The Joker has the same powers of movement as the last piece the opponent moved, which is what I've been trying to program with my Joker function.

2. The Joker mostly has the same powers of movement as the last piece the opponent moved, but there are exceptions for particular pieces. For example, it might not be able to promote or castle.

3. The Joker is limited to the type of move of the opponent's last move. For example, if the opponent moved a Queen, diagonally, the Joker would be able to move diagonally, but not orthogonally.

4. The Joker is limited to the type and direction of the opponent's last move. For example, if the Queen moved vertically forward, the Joker could move vertically forward, but it could not move vertically backward, horizontally, or diagonally.

5. The Joker is limited to the type, direction, and distance of the opponent's last move. For example, if the Queen moved vertically forward 4 spaces, the Joker could move vertically forward up to four spaces.

6. The Joker is limited to the type, direction, and precise distance of the opponent's last move. For example, if the Queen moved vertically forward 4 spaces, the Joker could move vertically forward 4 spaces, no more and no less.

In my fork of the Apothecary Chess 1 preset, the problem I've currently come up against may be due to endless recursion. When I try moving the Joker, the script crashes. What I think is happening is that after the Joker moves, it runs code for the other Joker, and now that the value of lastpiece is j or J, the Joker function recursively calls itself again and again without ever exiting. I just tried one way of fixing this, but it didn't solve the problem. Since it's late, I will not continue with any more attempts tonight. I just wanted to share what I think the problem is.

The problem was caused by using #lastpiece instead of var lastpiece. The former inserts the value into the line during preprocessing, which doesn't work out so well for null or empty values, while the latter looks it up while evaluating the expression. These will work instead.

def Joker fn const alias var lastpiece #0 #1;
def Joker-Range fn join const alias var lastpiece "-Range" #0;

One thing that has come up while examining your code is how you want the Joker to move after a piece that moves differently for each side, such as the Pawn. Should it move as the enemy Pawn, which is how it currently works, or as its own Pawn? For the latter, these should work:

def Joker fn const alias flipcase var lastpiece #0 #1;
def Joker-Range fn join const alias flipcase var lastpiece "-Range" #0;

While these changes eliminate the problem you were having, there is still a problem with actually moving the Joker piece. One problem is that the Joker doesn't properly handle pieces that use subroutines instead of functions. But even with pieces that just use functions, it is not working properly. I'm getting too tired to continue looking into this today. Maybe I'll make more progress tomorrow.