Check out Atomic Chess, our featured variant for November, 2024.

Item Index Information

The Fairychess Include File Tutorial is a reference work. It is categorized as: Not categorized.

The Fairychess Include File Tutorial. How to use the fairychess include file to program games for Game Courier.

Author: Fergus Duniho.

Other Information

The board used for this game has 8 row(s), 8 column(s), 64 cells/squares.

Other Options

Browse items that also start with the letter T.
Browse items that also start with the letters Th.
Browse items that also start with the letters The.
Browse similar items.
Browse items with a similar board.
Add a comment or rate this item.
Skip to comments section.

Index Maintenance

[edit] [links] [associate image] [associate text] [info] [quick edit]

Group ID 'gamecourier'

Credits

Author: Fergus Duniho.

Comments

The Fairychess Include File Tutorial. How to use the fairychess include file to program games for Game Courier.

🕸📝Fergus Duniho wrote on Sun, May 12 10:20 PM EDT in reply to Fergus Duniho from 06:29 PM:

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.

🕸📝Fergus Duniho wrote on Sun, May 12 06:29 PM EDT:

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

🕸📝Fergus Duniho wrote on Wed, Apr 10 09:02 PM EDT in reply to Daniel Zacharias from 07:51 PM:

I still don't get why the previous way wasn't working since I wasn't changing the pawn subroutine which seems to modify promotion options before the last rank.

The Pawn subroutines are only for actual moves, but nothing was being done to handle variable values of wprom or bprom for potential moves. The stalemated subroutine was supposed to provide a list of all legal moves, but it was omitting moves where someone declines promoting a Pawn. By having functions that dynamically calculate what a piece may promote to, it is now able to provide an accurate list of legal moves for games with variable promotion rules, such as Gross Chess has.

Anyway, this reveals another, but more minor, problem, which is that when a pawn gets to the promotion zone the text in the option selection box is large enough that the lines overlap slightly.

I increased the line-height and made some changes to the borders.

🕸📝Fergus Duniho wrote on Wed, Apr 10 08:33 PM EDT in reply to Fergus Duniho from 03:57 PM:

For Obento Chess, you might use functions like these:

def White_Pawn-Promote elem - rank #0 9 ((FP) (FP) (F));
def Black_Pawn-Promote elem rank #0 ((f) (fp) (fp));

That should be this:

def White_Pawn-Promote elem - rank #0 9 ((F P) (F P) (F));
def Black_Pawn-Promote elem rank #0 ((f) (f p) (f p));

Daniel Zacharias wrote on Wed, Apr 10 07:51 PM EDT in reply to Fergus Duniho from 03:57 PM:

Thank you, that does work better; although I still don't get why the previous way wasn't working since I wasn't changing the pawn subroutine which seems to modify promotion options before the last rank.

Anyway, this reveals another, but more minor, problem, which is that when a pawn gets to the promotion zone the text in the option selection box is large enough that the lines overlap slightly.

List all comments and ratings for this item.

Add a comment or rating for this item.

The Chess Variant Pages is an amateur, hobbyist website that has been run by volunteers since it was founded in 1995. It focuses on documenting games based on, related to, or similar enough to Chess and on letting you play many of them.

Who What When Where Why Which How

Privacy

Operating expenses are covered through advertising and donations. Help out by making a PayPal donation or by shopping with these affiliate links:

https://953232.niammsnz.asia/index/displayitem.php
First Created: Sunday, March 29th, 2020
Last Modified: Friday, June 26th, 2020
File Timestamp: Wed, 06 Mar 2024 17:23:38 -0500
[info] [links] [edit]

Item Index Information

Other Information

Other Options

See Also

Index Maintenance