Comments/Ratings for a Single Item

Still works in Windows 10, but can't get any internet play to work. If anyone out there knows how to set it up I'd be grateful.

I haven't used it that way since I had Windows 95. When I did, I arranged with another person regarding the time and game we would play together, and I believe I was in communication with him while setting up the connection for Zillions-of-Games. But I do not remember the steps we went through to do that. Also, back then, I had a dial-up internet account. I now have broadband, which works differently, and I don't know if that will make a difference.

Guess I could try emulating windows 95

Guess I could try emulating windows 95

I don't think that will help. I think you just need to coordinate with another person who is willing to play against you at a certain time.

Yes, that's what I did. We were in the same room and couldn't get it connected up in Windows 10 :p

The Zillions user forum seems dead. I registered, but can't start a new topic.

I have the following move macro:

(define Mason-step ((verify (empty? $1))(create Stone) $1 add))

How do I turn this into a slide? All my attempts are generating pares errors.

For a slide, you need a loop. Since I don't know how your Mason piece moves, I'll give you an example from the Chess.zrf:

(define slide        ($1 (while empty? add $1) (verify not-friend?) add))

This can be used for Bishop, Rook, or Queen moves, though it does have a special one for Rook moves that also sets an attribute for whether it can still castle to false.

The main feature that makes this a slide instead of a single-step move is the while loop. $1 is the parameter with the value of the direction to move. After moving once in this direction, it checks whether it is empty, and if it is empty, it allows the move with the add command, and it moves again in the same direction. If it reaches an occupied space or the end of the board, it breaks out of the loop, because the empty? condition is no longer met. At this point, it tests the same space with (verify not-friend?) to tell whether it is one without a piece belonging to the same player. If it's an enemy piece or empty, it will allow the move with the add command.

The Rook-slide looks like this:

(define rook-slide (
  $1
  (while empty? (set-attribute never-moved? false) add $1)
  (verify not-friend?)
  (set-attribute never-moved? false)
  add
))

This uses the same method of a while loop, but in addition to allowing a move to a certain space, it makes sure that the allowed move includes the the operation of setting the attribute never-moved? to false.

I solved the Mason move by using single-step moves and add-partial.

The last piece I'm coding can push a line of pieces. This almost does what I want:

(define push ($1 (verify not-empty?) cascade (while (not-empty? $1) $1 cascade) $1 add))

But if the piece at the end of the line is at the edge of the board, I want to capture it (push it off the board). The above code disallows the move if the last piece is at the board's edge. I wonder if there is a solution using zones or dummy squares.

The piece is inspired by Nemeroth's Go Away (but it can only push one line at a time, and any effects of or on the pushed pieces are ignored).

Indeed, the whole game is inspired by Nemeroth, but on the whole, it's much simpler to code in Zillions. There is an unapproachable piece, a piece that turns the target square to stone (by a rifle-capture-like move), a piece that moves and captures as a king, a piece that lays down a line of stones, and so on. Stones do not move on their own but can be captured or pushed (a bit like ichor without the bookkeeping). Victory is by stalemate or opponent's repetition. There is no concept of compulsion or multiple-occupancy squares.

My game loses much of Nemeroth's peculiar flavor but is interesting in its own right. Pushing pieces of the board will make it complete. I will need to clean up the Zillions file and author a page.

You could test each space with on-board? or not-on-board? and provide a different move when the space is not on-board.

This code works perfectly with correctly defined zones:

(define push-n (n (while on-board? (if empty? add (verify false))(if (in-zone? board-edge-n) add (verify false)) cascade n))) (define push-e (e (while on-board? (if empty? add (verify false))(if (in-zone? board-edge-e) add (verify false)) cascade e))) (define push-s (s (while on-board? (if empty? add (verify false))(if (in-zone? board-edge-s) add (verify false)) cascade s))) (define push-w (w (while on-board? (if empty? add (verify false))(if (in-zone? board-edge-w) add (verify false)) cascade w)))

The (verify false)'s are essential to stop move generation when the final square is found, otherwise, Zillions crashes. I decided to use rook-wise pushes to complement the piece's bishop-like move.

Using (verify false) is a clever idea. It's sort of like using return in a function for some other language. You might have gotten the same effect by using else. For example, this might work:

(define push-n (n (while on-board? (if empty? add else (if (in-zone? board-edge-n) add else (cascade n))))))

However, it does use else twice to create an if-elseif-else structure, and breaking out with something like a return is an equally valid way to handle this.

Since the first two conditions have the same effect, this might also work:

(define push-n (n (while on-board? (if (or empty? (in-zone? board-edge-n)) add else (cascade n)))))

And let's try a general push routine without the zone:

(define push ($1 (while on-board? (if (or empty? (not-on-board? $1)) add else (cascade $1)))))

I had my two desktop computers play four games of Chess on Zillions-of-Games. For the first two, each computer had 1 second of thinking time, and the new computer won both games. For the next two, I gave my old computer 2 seconds of thinking time but kept the new one at one second. For these, the game was a draw when my new computer played White, and the old computer won when it played White.

My hypothesis is that a better CPU helps Zillions-of-Games play better. My new computer's CPU is better in two out of three ways. It has more cores, and each core can be overclocked to a higher speed. But the old computer's CPU is better in one way, which is that the base speed of each core is higher. I suspect the higher overclocking is making more of the difference, because Zillions-of-Games is old enough that it might not make use of multiple cores.

One other difference between them, which I'm not sure is an advantage either way, is that the new one is Intel, and the old one is AMD. Another factor that may be at play is that the new computer has faster RAM and four times as much RAM. Still, more testing needs to be done to see if the new computer consistently has an advantage.

I played four more games of Chess between my two computers today, and the results were more inconclusive. With 2 seconds of thinking time, each played White once, and White won both games. With 3 seconds of thinking time, my new computer won as Black, but the game was a draw when it played White. These results give a slight edge to the new computer, but the results were closer than yesterday. It's probably thanks to the collapse of Moore's Law that the CPU cores in my new computer are not leaps and bounds better than the ones I got 12 years ago. This is why CPUs started to increase in number of cores instead of in clock speed.

The rule of thumb is that engines gain about 70 Elo for each doubling in speed or thinking time (100 ln(speed)). Ofcourse it is difficult to know the speed advantage the new computer gives to Zilions, as, as far as I know, Zillions does not print the number of positions it has searched. But you could benchmark this with some other chess engine.

Tests with as few as 10 games are usually meaningless. The statistical error in the result of a match of N independent games is 40%/sqrt(N). For N=10 that amounts to 13%, and each 1% score difference equates to about 7 Elo. So the standard deviation of the measured Elo difference would be nearly 100 Elo, more than you would get from a speed doubling. To have a good chance (like 86%) that a speed increase of (say) 21%, (~21 Elo or 3% result improvement, i.e. expected match result 53%) would result in winning a match you would need about 170 games. 

I'm not sure about the base of the logarithm you are talking about. Is it 2 or e? Anyway for larger boards things are probably even worse, I'd assume.

This is natural logarithm (base e). So ln 2 ~ 0.69, i.e. 69 elo for a speed doubling.

This is for engines playing orthodox chess, and seems to be quite universal. (Except when the level of play gets so high that almost all games end in a draw; then doubling the speed doesn't give so much Elo gain anymore, because even a perfect player can only beat a weaker player when the latter makes an error.)

To have a good chance (like 86%) that a speed increase of (say) 21%, (~21 Elo or 3% result improvement, i.e. expected match result 53%) would result in winning a match you would need about 170 games.

That's too many to do manually. Even if I manage to get them to play each other automatically, I would have to start each game manually. I figure that in terms of clock speed, the two CPUs are close enough that neither will have much advantage over the other. While the new computer can boot up faster and operate more responsively, this is due to improvements other than clock speed. Back when Zillions-of-Games came out, clock speeds were increasing very quickly, and I was hoping it would get more powerful on newer computers. But clock speeds have now reached a plateau where other improvements, such as adding new cores or instructions to the CPU, are more cost effective. So, as far as using Zillions-of-Games goes, I don't think my new computer is significantly better.