Comments/Ratings for a Single Item

I have been busy improving GAME Code this week. Here are some of the latest
improvements. Instead of using explode to split a line of code into strings
of non-whitespace, I have written some parsing functions. One parsing
function checks whether a line of code is a move, returning each item in a
separate argument. If it's not a move, a second parsing function is used.
This function parses out quoted strings, arrays, and non-whitespace
strings. Here's how it works.

It goes through each character of a line. It normally skips over
whitespace. When it finds a double quotation mark immediately after
whitespace, it copies everything until the next one as a single string.
When it find a left parenthesis, it copies everything until the next right
parenthesis, then recursively calls the parsing function on this. This
generates an array. Otherwise, it copies as a single argument whatever
text falls between whitespace. Also, it does additional preprocessing only
on unquoted nonarrays. So if you want to use 'origin', 'dest', or
'moved' as strings rather than as special variables, you can quote them
to use the strings. This is required if you want to use setglobal to set
the value of one of these variables.

I've added target and check operators to the Polish notation calculator.
These work sort of like switch and case. They are used for speeding up the
search for pieces that might be checking the King. Details are in the
documentation.

The fn operator now accepts nameless functions as arrays, which allows the
creation of nameless lambda functions.

Over the weekend, I added the ability to use parentheses for expressing
arrays. For example, this will now set an array of all white pieces in
Chess:

set white (K Q R B N P);

Arrays are parsed recursively, so that nested parentheses will yield
multi-dimensional arrays.

When lines are evaluated by the Polish notation calculator, the contents
of arrays are not automatically evaluated. For example

set a * (+ 4 5) (- 9 5)

should not evaluate to 36.

But arrays may be conditionally evaluated by the logical operators and,
or, nor, nand, and cond, and also be eval and fn. For example,

set a * eval (+4 5) eval (-9 5)

would yield 36.

When given arrays as arguments, the binary logical operators will evaluate
the first array first, then evaluate the second only if its value is needed
to determine the value of the expression. For example,

set a or (== 4 4) (!= 4 7)

will evaluate only (== 4 4)

The cond operator is the equivalent of ?: in C or PHP. It will evaluate an
expression, and if it is true, it will evaluate the array following the
expression, but if it is false, it will evaluate the second array
following the expression. For example,

cond != 6 6 (== 7 9) (<= 9 7)

will evaluate (<= 9 7) but not (== 7 9)

Last night, there was still a problem with using parentheses with
recursive functions. That problem is now fixed. It is now possible to
write a recursive function like this one for finding a number's
factorial:

def fac cond equal #0 1 1 (* #0 fn fac dec #0);

Note that #0 is now the first placeholder instead of #1. I changed all the
placeholders in chess.txt to accomodate this.

This particular function has been tested and shown to work. It first
checks whether the value passed to it is equal to 1, with 'equal #0 1'.
If it is 1, it returns 1. Otherwise, it evaluates the array (* #0 fn fac
dec #0), which multiples the value passed to the function, #0, with a
recursive function call of one less than the value passed, dec #0.

Control structure commands that introduce a body of code can now be ended
with a colon instead of a semicolon. These include if, elseif, else, do,
for, foreach, switch, case, and default. I did this, because I think it
looks better. In other languages that end lines with semicolons, these
commands normally do not end with semicolons. Semicolons are still allowed
for backwards compatibility with old code. The program code is now broken
up with a specialized parsing function instead of exploding on
semicolons.

The foreach command is now an alias for the for command. Both commands
work much like foreach from Perl or PHP. By using an array instead of a
string for naming the for variable, you can get both the key and the value
of each array member. For example, the following code lists all the spaces
of the board, assuming the 64-times limit of echo isn't exceeded:

foreach (key val) spaces:
  echo #key #val;
next;

I am currently developing code for checking whether a player is checkmated
or stalemated. It is not all working right yet, but if anyone wants to
take a look at it, you will find it here:

http://play.chessvariants.org/pbm/includes/checkmate.txt

I am using it with a new version of the Chess preset:

http://play.chessvariants.org/pbm/play.php?game=Chess&settings=checkmate

This preset is only for testing and should not be used for ongoing games.

Also, so that single and double quotation marks can be entered in the form
fields for GAME Code, I have switched to storing strings in settings files
with the heredoc format. This will not affect current presets unless they
are resaved.

This comment, which I accidently posted on the wrong page a couple days
ago, belongs on this page:

I added the following new functions to the Polish notation calculator
today:

checkmaxsteps
checknsteps
checkpath

These all handle movement that may go along a winding, unobstructed path,
such as the movement of some pieces in Jetan. The checkmaxsteps function
checks whether a piece may move from one space to another within a
specified number of steps from one adjacent space to another. The
checknsteps function checks whether a piece may move from one space to
another in exactly a specified number of steps. Both of these functions
allow movement through the origin space and repeated movement through the
same space. They are both handled by a recursive function that goes
through all possible paths until it finds one that works. The checkpath
function checks whether a piece can move from one space to another by
following a specific path, given as a set of paired directions. To
illustrate how these work, here are two alternate ways to handle the
Squire from Holywar:

Barring possible mistakes, here is the long way that uses 16 checkpath
functions for all possible paths:

checkpath origin dest (1 0 1 1) or checkpath origin dest (1 1 1 0) or
checkpath origin dest (1 0 1 -1) or checkpath origin dest (1 -1 1 0) or
checkpath origin dest (-1 0 -1 1) or checkpath origin dest (-1 1 -1 0) or
checkpath origin dest (-1 0 -1 -1) or checkpath origin dest (-1 -1 -1 0)
or
checkpath origin dest (0 1 1 1) or checkpath origin dest (1 1 0 -1) or
checkpath origin dest (0 1 -1 1) or checkpath origin dest (-1 1 0 -1) or
checkpath origin dest (0 -1 1 1) or checkpath origin dest (1 1 0 1) or
checkpath origin dest (0 -1 1 -1) or checkpath origin dest (1 -1 0 1);

Here is the short way that uses checknsteps in combination with
checkleap:

checkleap origin dest 1 2 and checknsteps origin dest 2;

The checkleap function makes sure that the piece is going to a space a
Squire could move to, then the checknsteps function makes sure it can get
there in exactly two steps.

I have now modified the Alfaerie-JPG version of the Chess preset to use the
code I've been working on for identifying check, checkmate, and stalemate.
For each of these, it will put an appropriate message above the board, and
for checkmate and stalemate, it will automatically update the status.

I have also created the commands won, drawn, and lost for updating the
status. The <B>won</B> command declares the current player to be the
winner, <B>lost</B> declares the current player's opponent to be the
winner, and <B>drawn</B> declares the game drawn. Don't confuse this with
draw, which is a command for drawing cards. The lost command is an alias
for resign, to be used when a player has already lost without resigning.

Oh yes, this is a great addition for so many reasons...  Thanks!  I'm
especially pleased that pieces can now be represented by the correct
letters for the game, without requiring a proliferation of piece sets. 
The ability to use the plus-sign in the name for shogi pieces is a very
nice touch, too.

I would like to suggest something, though.  Right now, when moving a piece
you can either enter the piece type ('P e2-e4') or not ('e2-e4').  I
always do the former, because it makes it easier for me to keep track of
games.  Some opponenets do, some do not.  I would be nice if, when
entering a simple single-move, like 'e2-e4', it would automatically add
the 'P' or 'p'.  

Thanks for the consideration.  You have done a lot of good work on
improving the Game code recently!  I need to get to work on presets using
the new features for wildebeest chess, lions & unicorns chess, and others.

I am attempting to change the name of my recent submission from 'Chieftain
Chess with Preset' to 'Chieftain Chess', now that a preset page is
available. I am also trying to indicate it is multi-player, with 1-4
players per side, for a total of 2-8 players. I seem to be having 2
problems. First, when I try to do the name change, I get this error
message:
 Error performing query: Duplicate entry 'MSchieftainchess' for key 1
Second, is there a way to indicate a range in the number of players per
side?  I will put in '1-4' and '2-8', but what comes up is '1' and
'2'. 
Any information or assistance will be greatly appreciated.