| Author | Message | ||
| Harry Buntz (Tabu)
|
I'd like to see the capability to play connection games such as Hex or Twixt. | ||
| Marek Ctrnact (Marek14)
|
I think this type of games is already playable (see Mini-Go). It is just very hard to do. | ||
| Todd Baumann-Fern Sr. (Budfern)
|
Really, I thought it wasn't possible also. Good to hear that it is possible.  One of the hings that drew me to this program was hoping these games would be playable. Well, if it could be made easier to create conection games that would be a nice improvment. My hope is that card games (like hearts) will someday appear. | ||
| Todd Baumann-Fern Sr. (Budfern)
|
Really, I thought it wasn't possible also. Good to hear that it is possible. One of the things that drew me to this program was hoping these games would be playable. Well, if it could be made easier to create conection games that would be a nice improvment. My hope is that card games (like hearts) will someday appear. | ||
| Marek Ctrnact (Marek14)
|
Sorry but that is absolutely impossible with the current engine. The one thing Zillions cannot handle is hidden information. See, in Hearts you can see your own cards, but no of the other players can. That is impossible to do in Zillions and I doubt if the current algorithms could be adapted to this. For the same reason, you can't program games like Stratego. However, I think it chould be possible to program standard Solitaire - you could add a pool of "undecided" cards and every time you would reveal another card the computer would randomly substitute actual card from pool for it. Just an idea. | ||
| David GLAUDE (Glu)
|
The real problem of Zillion and Hidden informations, is that we can make the information hidden to us (provided we use the same bitmap, don't wach the message line and move list). But it is difficult (IMPOSIBLE) to hide information to the engine ;-). Who want to play Stratego against a computer that know where is you flag and bombs. As far as I remember, there has been computer version of Stratego that where well known for cheating at you by using information that should be hiden. By the way, the NO-hidden-information problem make it difficult to play any Card Game. David GLAUDE glu@who.net | ||
| Patrick S. Duff (Pduff)
|
I've been giving the problem of hidden information in Zillions games some thought lately. Imagine a game with a position which makes any piece stopping there invisible to the other players for five turns. Or imagine a piece in Stratego which is attacked. Both the losing piece and the winning piece should be visible to both players for one turn, then the winning piece should become hidden again. Or suppose you have a game where some of your pieces are visible to you only (facing you, or in your hand), some are visible to everyone (face up), some of them are invisible to everyone (face down), and some are visible only to your opponents (facing away from you). Consider the various kinds of blindfold chess. I see no reason why the "(moves ...)" and "(drops ...)" logic cannot be written to use hidden information for the current player (either human or computer) and not access it when generating moves for the other players. I think the current rules language can support all of the above hidden-information games. (Can anyone think of a type I've left out?) For instance, if a piece has never been seen, it can have the "hidden" attribute set to true. For multi-player games, you'd need one attribute for each player. But in some cases it would be nice to have a "set-position-attribute" command, in order to assign persistent values to positions as well as players. I can imagine games where flags and zones would fall short. It would also be nice to have "(hide-piece ...)" and "(unhide-piece ...)" commands which would toggle the piece's normal graphic with a "hidden" graphic. Using an all-transparent graphic would make the piece "invisible". A more general version would be "(next-piece-graphic ...)" and "(previous-piece-graphic ...)", which would be useful in both hidden-information and other games. There's no easy way to "age" an attribute without using lots of attributes (e.g., changing "hidden_for_three_turns" to "hidden_for_two_turns"), and the number is presently limited to 32. But I understand that this limit is being raised significantly in the next release. If anyone can pinpoint a situation where the language needs to be extended to handle (or better handle) hidden information, please add to this thread. | ||
| Patrick S. Duff (Pduff)
|
This thread started out as a request for support for connection games. This weekend I implemented Lines-of-Action, a type of connection game. Everything appears to be working correctly, but I'm still testing it to make sure. When LoA.zrf gets released sometime in the future, look there for an example of how to check if pieces are connected. I found a number of places where improvements to the rules language would have made things easier, but the current version of the rules language got the job done. (I've posted my suggested improvements elsewhere on this message board.) | ||
| David GLAUDE (Glu)
|
To Patrick S. Duff About Line of Action, I have been thinking about how to make it and I have friend wanting to write it. It is a very nice game from Artificial Inteligence perspective because a lot of rechearch activities are actually happening concearning this game. It mean that we can compare the performance of Zillions against domain specific games (on a not too well known game, not like chess, go, ...). However there are rules difficult to implement: * Counting the number of piece on a line to know move distance. * Checking for win condition (all piece connected together the connection issue). * There is also a special condition, when you make your group simultaniously as the opponent group. That condition is difficult to "detect" and "implement". Do you support that? Now when everything is implemented, there is still a problem concearning "speed" of Zillions for complex game implentation. Is Zillions playing fast=well your implementation of LOA? David GLAUDE (glu@who.net) | ||
| David GLAUDE (Glu)
|
The problem with hidden information game... To Patrick S. Duff The problem with hidden information game, is that Zillions can use all the information available to it in order to compute the best move possible. If the information is avaible, Zillion is going to use it. There might be a way to implement limited hidden information game, if and only if the user Remind what piece is where and reveal it to Zillions only when required by the rules. Like "Secret Chess": Standard chess board, all piece are hidden (not the position but the rank), Piece move following the standard chess rule, Initial position are choosen secretly by both side separately, Pawn are at thier standard position. At the begining of the game, all piece are unknown, by moving a piece, you show some of it's capabilities. I see the following capabilites: Short Ortogonal move: Queen, Rook, King. Short Diagonal move: Queen, Bishop, King. Long Ortogonal move: Queen, Rook. Long Diagonal move: Queen, Bishop. Jump: Knight. Queen exist: A special global flag when the queen is detected to make sure we only have one and Zillions knows about it. At the begining a piece can take any possible move. As soon as you make a move you get the associate attribute. If you make a long move you are not the King nor a Knight. If you make a Ortogonal move you are not a Bishop anymore. If you make a Diagonal move you are not a Rook anymore. All user piece (except pawn) are "Neutral" type that start without any flag. When you move, you start to get flag that limit your possible movement. All the compute piece have the same "picture" but different real name and move capabilities. That way, the computer cannot cheat (however the user can). Now it is difficult to explain Zillions that we can only have two rook, bishop and Knight. The problem for Zillions-of-Games is that Zillions don't know that we don't know the piece capabilities. Zillions is not aware of the hidden information. Also, there is no easy way to avoid the user to cheat. The same way, game like Stratego could be implement. The user (somehow) reveal (promotion) the grade of a piece when the need occur. The problem is that from Zillions point of view, the use CHOOSE the grade and can always take a wining one. I think those two examples show the limitation of Zillions concearning hiden information: * Zillion don't know we are not suppose to know what is on the board. * Zillion believe we can choose the information that is hidden to the computer. * If we don't hide (reveal only when needed) information, Zillions AI is gonna use it. * The AI is not prepare to deal with guessing and/or probabilistic problem of hiden information. * Also Zillions don't know how to bluff, fake, make believe. Anybody else have an idea about Hiden information? Let me remind the idea of a "Zillions-of-Card-Games" that has been suggested in the past. David GLAUDE (glu@who.net) | ||
| Patrick S. Duff (Pduff)
|
Yes, I've got a complete implementation of Lines of Action, including detecting both friendly connectivity and enemy connectivity on each move, and Zillions plays reasonable well. Right now I have fourteen variants working, and I'm planning to add seventy more, for a total of eighty-four different ways to play. The move logic for the remaining variants is pretty easy and probably will be finished tonight; the time consuming part will be the work I need to do on the additional board and piece graphics. I did make one decision which some people may disagree with. In the "official" rules, a simultaneous win is counted as a win for the moving player. In my implementation I made this a draw, in order to encourage the moving player to find another move which is a clear win. If anyone feels strongly about this, you can easily edit my rules file to make this a draw. | ||
| Patrick S. Duff (Pduff)
|
Regarding hidden information games: I stand by my statements that information can be hidden from both the human and the computer players by appropriately coding the move generation logic. Where there could be problems is inside the engine while Zillions is executing its internal position evaluation function(s). But I see no reason why the engine couldn't be coded to handle hidden information appropriately. I suggest the developers consider adding support for this in a future release. |