Comments by FergusDuniho

I am running a test of a new script for editing comments. It is a single script that will handle comments on pages and subjects. It is intended to replace createcomment.php, previewcomment.php, addcomment.php, createsubject.php, previewsubject.php, addsubject.php, usereditcomment.php, userpreviewcomment.php, and usermodifycomment.php.

I have written a new function for database-funcs.php called insert_row(). This script uses it to insert new comments.

As a test, I am updating it with this third paragraph.

You can screen those out with a line that rejects ferz moves. Here is a revision:

def Osprey fn (checkride #0 #1 1 1 and empty #0) 
  where #0 0 * 2 sign - rank #1 rank #0 
  #1 
  or fn (checkride #0 #1 1 1 and empty #0) 
  where #0 * 2 sign - file #1 file #0 0 
  #1
and not checkleap #0 #1 1 1
or checkleap #0 #1 2 0; 

Since it works for displaying legal moves, it's probably because the Pawn functions are only for potential moves, and the Joker is trying to use one of the Pawn functions when making an actual move. Specifically, I think it fails on the line "and empty #1" in the Pawn function, because that space is occupied for an actual move. Some options include changing your rules, rewriting the Pawn functions to handle both potential and actual moves, or using a Joker subroutine for actual moves, which would let you undo the Joker's move before testing it with a function, then redoing it if it is legal.

I was looking at data on Cloudflare, which is not available through here.

That looks correct.

You don't have to imagine bent sliders. If a Rook captured a Scout on its starting space, I presume it would not be able to capture a Cleric still on its starting space. Since Chesire Cat Chess removes spaces from the regular playing area and still includes sliders, it makes sense that it would allow moving over non-existing spaces. But I think that the rule in Chesire Cat Chess is going to be the exception, not the default behavior. Game Courier, for example, would not allow movement across non-existing spaces, and for a game like Chesire Cat Chess, an exception would have to be programmed in. In this game, there are non-existing spaces only between spaces whose only purpose is to provide a launching area for extra pieces to enter the main playing area.

The range function looks correct. Where the Aanca function calculates 1 or -1, you want yours to calculate 2 or -2. The simplest way is to multiply the return value of sign by 2.

They could just be called disappearing squares or vanishing squares or something along the same lines. They're nothing new. In Chesire Cat Chess and Wormhole Chess, all the squares of the board are like that. What's novel about this game is using them for only some of the squares. This use of them could be termed launch squares.

Since it's most similar to the Aanca, let's first look at how the code for that piece works:

def Aanca fn (checkride #0 #1 1 1 and empty #0) 
where #0 0 sign - rank #1 rank #0 
#1 
or fn (checkride #0 #1 1 1 and empty #0) 
where #0 sign - file #1 file #0 0 
#1
or checkleap #0 #1 1 0;

The code works backward, as usual. So it first checks whether the move is a one-space orthogonal move. If it is, it returns true immediately. If not, it continues. To calculate whether it makes a legal Aanca move, it needs three coordinates. #0 is the origin, and #1 is the destination, but it also needs the coordinate for the space on which it changes direction. Unfortunately, variables cannot be assigned in functions. The next best thing is to use a Lambda function that can take arguments. These appear in parentheses after the fn operator. Each one is the same, but each one gets fed different arguments. The second argument is always #1, which is the destination space. The first argument is the space where the move changes direction. Since each destination space falls into one of four quadrants, and there are two possible paths to the destination through a particular quadrant, this information is used to reduce the paths that need to be checked to two.

It first checks whether the move is going left or right, and based on that, it selects the space to the left or right of the origin space as the turning space. It then makes sure it is empty and that there is a legal Bishop move from it to the destination space. If that fails, it checks whether the move is going forward or backward, and based on that, it selects the space ahead or behind the origin space as the turning space. It makes sure this space is empty, and if it is, it makes sure there is a legal Bishop move from that space to the destination. If there is, it returns true, and if there is not, it returns false. I expect that the piece you want can be done with only slight modifications to this function.

I didn't say to get rid of the else clause. I said to get rid of the else. Just the else. A single line of code.

I noticed today that this directory didn't have group write permissions set. I set it, changed the owner and group from apache to chessvariants, and it allowed me to upload and delete a file, because chessvariants and apache are in each other's group. You should be able to upload files now. Let me know if you still have any trouble.

I just moved up and rewrote the Actual vs Potential Moves section. I also revised the section called "A Real Example from Chess", which now follows it.

While I could add code to Game Courier for enabling GAME Code programs to modify the images in piece sets, it would not work in Edit mode. So, if you want to use piece images that are not in your current set, you should change it to use a different set.

Tonight on Jeoprady, there was a question about what one-letter abbreviation, which is not K, is used for a Knight in Chess. I was surprised that no one at all got the correct answer. Someone who didn't choose the question jumped in with the answer L, which was wrong. Even if none of them knew Chess, simple phonics should have led someone to conclude that the answer is N.

The link to the website doesn't work, and we have another link page for this same organization. But this page is more informative. I'll leave it up for now in case anyone knows anything about this organization's current status.

As long as you evaluate actual moves in the Post-Move sections, you have to bear in mind that potential moves are evaluated before a move would be made, and actual moves are evaluated after a move has been made. This means that you have to sometimes use different code for potential and actual moves. That's true of the King here. You should use both a function and a subroutine for the King's movement. The function should handle only potential moves, and it should stop a King from making its special move out of check before it makes its move. The subroutine should handle actual moves, and it should undo a King's special move after it has been made to make sure the King didn't move out of check with that move, then redo it if it was legal.