The Chess Variant Pages
Custom Search




[ Help | Earliest Comments | Latest Comments ]
[ List All Subjects of Discussion | Create New Subject of Discussion ]
[ List Latest Comments Only For Pages | Games | Rated Pages | Rated Games | Subjects of Discussion ]

Comments/Ratings for a Single Item

Later Reverse Order Earlier
This item is a game information page
It belongs to categories: Orthodox chess, 
It was last modified on: 2020-04-21
 By Daniel  Zacharias. Expanded Chess. An attempt at a logical expansion of Chess to a 10x10 board.[All Comments] [Add Comment or Rating]
Carlos Cetina wrote on 2020-07-03 UTC

Set. Problem solved. Thank you very much for your help, Fergus.

osprey move corrected

 


Fergus Duniho wrote on 2020-07-03 UTC

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; 

Carlos Cetina wrote on 2020-07-03 UTC

Interesting deduction, Ben. Let's see what Fergus thinks.


Ben Reiniger wrote on 2020-07-03 UTC

I'd guess it's seeing a 2-leap followed by a bishop move inward as legal?  And that doesn't matter for the Aanca because those same squares can be reached legitimately by a shorter path.


Carlos Cetina wrote on 2020-07-03 UTC

Yes, but then how to explain that the program allows moving the piece like Ferz?

osprey move


Fergus Duniho wrote on 2020-07-03 UTC

That looks correct.


Carlos Cetina wrote on 2020-07-03 UTC

With the following code I have made some progress because the piece already can make the desired legal moves:

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
or checkleap #0 #1 2 0;

 

def Osprey-Range mergeall 
  leaps #0 2 0 
  rays where #0 0 2 1 1 
  rays where #0 0 -2 1 1 
  rays where #0 2 0 1 1 
  rays where #0 -2 0 1 1;

However something must be wrong since the program allows the Osprey to be moved as ferz. What do you think is the cause?


Fergus Duniho wrote on 2020-07-02 UTC

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.


Carlos Cetina wrote on 2020-07-02 UTC

Thanks. I think we are close to finding the solution!

Then the question is how do we get the where operator returns the 4 options:

where #0 2 0

where #0 -2 0

where #0 0 2 

where #0 0 -2

Is there any other digit to use instead of 0 that fulfills the desired purpose? I mean the zero that I previously underlined.

What is easy to deduce is that the first backward line of code should look like this:

or checkleap #0 #1 2 0;

Is my assumption about the Osprey-Range definition correct?

def Osprey-Range mergeall 
leaps #0 2 0 
rays where #0 0 2 1 1 
rays where #0 0 -2 1 1 
rays where #0 2 0 1 1 
rays where #0 -2 0 1 1;

Fergus Duniho wrote on 2020-07-02 UTC

The underlined parts are arguments to where, which takes three arguments. The first argument, which you haven't underlined, is the starting coordinate. The next one is a number of files, and the last one is a number of ranks. These values may be negative or positive, and this determines direction. Using these values, where returns the coordinate that is so many files and ranks away in the given directions. This is being used to calculate the coordinate of the turning square, which is one of the arguments for each of the Lambda functions. This uses sign, which returns -1, 0, or 1, depending on whether a value is negative, zero, or positive. When 0 comes first, it will typically be calculating where #0 0 1 or where #0 0 -1. Where 0 is last, it will typically be calculating where #0 1 0 or where #0 -1 0. When the destination is on the same file or rank, and it is not a Wazir move away, it may sometimes return where #0 0 0, which will be the starting space. Since there is no Bishop move to a space on the same rank or file, the function will return false for such a destination, which is correct. For potential moves, it will return false even earlier, since that space will still be occupied.


Carlos Cetina wrote on 2020-07-02 UTC

How should the underlined parts be read (interpreted)?

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;

 

Particularly, what do the underlined  0 's mean?

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;

H. G. Muller wrote on 2020-07-01 UTC
files=10 ranks=10 promoZone=3 promoChoice=!PQ1G2R2OZBN graphicsDir=/graphics.dir/alfaerie/ squareSize=52 graphicsType=gif pawn:P:ifmnDfmWfceF:pawn:a3,b3,c3,d3,e3,f3,g3,h3,i3,j3,,a8,b8,c8,d8,e8,f8,g8,h8,i8,j8 zebra:Z:Z:zebra:d1,g1,,d10,g10 knight:N:N:knight:c2,h2,,c9,h9 bishop:B:B:bishop:d2,g2,,d9,g9 osprey:O:DmpafyafsW:bird:e1,f1,,e10,f10 rook:R:R:rook:b2,i2,,b9,i9 gryphon:G:FyafsF:gryphon:b1,i1,,b10,i10 queen:Q:Q:queen:e2,,e9 king:K:KisO3:king:f2,,f9


Fergus Duniho wrote on 2020-07-01 UTC

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.


Carlos Cetina wrote on 2020-07-01 UTC

@Fergus,

Trying to edit a preset for this interesting variant by using the fairychess include file I'm almost done, just need to define the function of the Osprey which is a color-bound aanca, first jumping as dabbabah and then sliding outward as bishop. The following diagram shows its move:

I guess the code for Osprey-Range would look like this:

def Osprey-Range mergeall 
  leaps #0 2 0 
  rays where #0 0 2 1 1 
  rays where #0 0 -2 1 1 
  rays where #0 2 0 1 1 
  rays where #0 -2 0 1 1;

and the Osprey-Desc thus: 

"The %s jumps to the second square on the same rank or file, and then slides outward as a bishop."

Could you please tell me the code for such a function? No hurry; when you can spend some time it's fine. Thanks in advance.

 


Daniel Zacharias wrote on 2020-02-18 UTC

Yes, I should have included pawn moves in that. I meant 100 full moves but that probably is excessive. 
I think I'll just remove the last to move wins stuff from here. I still like the idea but it might make more sense as a separate variant all by itself. 

My reasoning for using zebras rather than camels is that I think it matches the other added pieces better. The gryphon starts with a diagonal step and continues as a rook, and the zebra's move can be described similarly. It begins with a diagonal step and then continues as a knight, jumping over any occupied squares on the way.

I'll try to fix the diagrams and rules.
 


Greg Strong wrote on 2020-02-18 UTC

My thoughts -

Zebra: The Camel is the more common complement to the Knight.  I think a Zebra is OK on a 10x10 board but would be less mobile than the Knight because more moves would be off-board (although a Camel is color-bound so also weaker than a Knight, but I think this is OK because a Bishop is a colorbound piece that could be considered the complement of the Rook.)  Also, if you keep the Zebra, I think you should keep the name as-is.

No Draws: I'm not sure how advisible this is.  The point of Stalemate is to give the player who is behind something to play for.  For repetition and 100-move rule, at a minimum, the written description needs to be clarified.  It currently says the "last player to move" wins, but your comment says "last to capture".  And for 100-move, do you mean "last to capture or push a pawn"?  That would make more sense.  And do you mean 100 half-moves, like the Chess 50-move rule?  Or do you really mean 100 full moves?  I think that would be too much and I don't see any reason to increase it at all.  Personally, I'd scrap all of this and leave all the victory/draw conditions as in orthodox Chess, but that is just personal opinion.


Ben Reiniger wrote on 2020-02-18 UTC

In the intervening time, we've had submissions from strong community members who do not have their real names displayed on these pages.  I (and I think we?) still have a slight preference for real names, for the encyclopedic nature of the site, but there are many sites now where site-famous people are later referred to as "user xyz of site abc," so maybe it's fine.

Another thing that changed in the time since your submission: the Diagram Designer.  The use of a period to denote a dot on the board (for movement diagrams) has been deprecated; you can replace them with a pound symbol (#), or a few other options.


Daniel Zacharias wrote on 2020-02-18 UTC

Wow, I didn't even see this until now. I'm sorry. In both checkmate and stalemate, the last move is the one that checkmates or traps the other player, so the player who is trapped loses. With insufficient material or repetition, the last player to capture would win. The winning condition was intended as an experiment in defining a drawless chess game. I have no idea if it would actually be more interesting or not than any alternative.

The other thing I'm not sure about is the zebras. Their jump fits with the other pieces but maybe it's too far for a board this small?

If my name is required I can add that


Fergus Duniho wrote on 2017-03-08 UTC

Having read your notes, stalemate is a win for the stalemated player. Since checkmate has not been mentioned as a specific win condition, I assume that checkmate, as a form of stalemate, is also a win for the checkmated player. Is this intentional? Or did you make an oversight in not mentioning checkmate?


Fergus Duniho wrote on 2017-03-08 UTC

In the winning conditions, I see no explicit mention of checkmate. It does mention that a player without legal moves has lost. So being stalemated is a loss, and consequently being checkmated is a loss too. This would be clearer to Chess players if it explicitly said that either checkmate or stalemate is a loss to the mated player.

Declaring a winner when the game ends after each player has made 100 moves without a capture or a pawn move is unusual. The rule in Chess is that the game is a draw after each player had made 50 moves without a capture or a pawn move. Since this condition occurs mainly in games in which both players have lost sufficient mating material, I wondering about the rationale for giving the win to a specific side.


Ben Reiniger wrote on 2017-02-25 UTC

Please add your name to your profile.


21 comments displayed

Later Reverse Order Earlier

Permalink to the exact comments currently displayed.