Game Rules
From StrategoUSA
Contents |
[edit] General Rules
The games will be played according to the standard Stratego rules, with range attacks enabled (scouts can attack during a range move).
[edit] Time Limit
The maximum time limit per move is 15 seconds. The average time per move should not exceed 5 seconds.
[edit] Move Limit
At 2,000 moves, a game will be declared a draw.
[edit] Two-Squares Rule
Literally from the ISF rules http://www.isfstratego.com/images/isfgamerules.pdf
10.1 It is not allowed to move a piece more than 5 times non-stop
between the same two squares, regardless of what the opponent
is doing. It does not matter whether a piece is moving and
thereby attacking an opponent’s piece, or just moving to an
empty square.
In pseudocode this would be:
method breaksTwoSquareRule(move)
limit := 5
for(count := 1 ; count <= limit ; count++)
prevmove := getMove(current-2*count)
if( !equal(move,prevmove) && !reverse(move,prevmove) )
return false
return true
method equal(move1,move2)
if(move.toField==move2.toField && move.fromField==move2.fromField) return true
else return false
method reverse(move1,move2)
if(move.fromField==move2.toField && move.toField == move2.fromField) return true
else return false
This rule must be implemented to participate in the tournament. However, Article 10.2 of the ISF rules, which pertains to scout moves, will not be enforced.
[edit] More-Squares Rule
Literally from the ISF Rules http://www.isfstratego.com/images/isfgamerules.pdf
11.1
It is not allowed to continuously chase one or more pieces of the
opponent endlessly. The continuous chaser may not play a
chasing move again more which would lead to a position on the
board which has already taken place.
11.2 Exception: chasing moves back to the square where the chasing
piece came from in the directly preceding turn are always
allowed as long as this does not violate the Two-Squares Rule
(Five-Moves-on-Two-Squares).
11.3 Definitions:
- continuous chase: the same player is non-stop threatening
one or more pieces of his opponent that is/are evading the
threatening moves.
- chasing move: a move in a continuous chase that threatens an opponent’s piece that was evading during the continuous chase.
Hereby:
- a/to move: a/to move plus attacking or a/to move to an empty square.
- to threaten: to move a piece next (before, behind or besides) a piece of the opponent.
- to evade: to move a piece away promptly after it has been threatened.
Pseudocode for the official More-Squares Rule:
forbiddenPositions := new List //this list contains all board positions that you are not allowed to create again
method isAttackingMove(move)
if (move involves combat) return true
else return false
method breaksMoreSquareRule(move)
// if combat, then there is obviously not a chase
if(isAttackingMove(move)) return false
// if we're moving opposite of last move, that is the
// domain of the two square rule
if(reverse(move,myLastMove)) return breaksTwoSquareRule(move)
// perform the move - update board state based on move - to allow testing validity
board := performMove(board, move)
// if the board state is in the forbidden list, then it's not valid
if(forbiddenPositions contains board.hash()) valid := false
else valid := true
// unperform the test move we just made
board := unperformMove(board, move)
return !valid
method doMyMove(move)
// if it doesn't break the rule
if (!breaksMoreSquareRule(move)) {
...code for executing move...
// add all board positions after your own moves to the forbidden list
forbiddenPositions.add(board.hash())
// record my last move
myLastMove := move
}
method doOpponentMove(move)
// if opponent is not running away from us...
if(!nextTo(myLastMove.endField,move.startField)
// empty forbidden list when opponent doesn't move from a field
// next to where our last move ended
forbiddenPositions := new List
...code for executing move...
This rule must be implemented to participate in the tournament.
[edit] Special Rules
Games between two computer programs frequently lapse into pointless chasing sequences and deadlocks. This section proposes additional rules for the 2009 tournament that are easy to implement and should make the games more enjoyable to watch. (NOTE: These rules were not implemented for 2009, but this section is left as a reference for future tournaments.)
Continuous Chase Rule
It is not allowed for a piece to chase another piece for more than 5 consecutive moves.
Exception 1: a move by a piece at immediate risk of capture by an opponent piece.
Exception 2: a move by a piece that is attacking a different opponent piece.
Chasing is extremely annoying to human opponents, and when computer programs play against each other frequently occupies a majority of the moves. This rule and the next eliminate chasing by computer programs.
Resumed Chase Rule
It is not allowed for a piece to chase another piece, suspend the chase for one or moves and then resume the chase against the same piece.
Exception 1: a move by a piece at immediate risk of capture by an opponent piece.
Exception 2: a move by a piece that is attacking a different opponent piece.
Exception 3: if a square immediately surrounding the chased piece has changed since the end of the previous chase.
Exception 4: if the move would immediately threaten two or more pieces.
This rule, combined with the previous and the next, prevents two computer programs from engaging in the endless deadlock cycles that plague computer match play. However, there are valid reasons for the piece to return to the chase square other than resuming the chase. Probe implements exceptions 3 and 4 for this purpose, but it would be helpful to find a more general exception.
Position Repetition Rule
It is not allowed to make a move that would repeat a position found earlier in the game.
Exception 1: a move by a piece at immediate risk of capture by an opponent piece.
Exception 2: immediately moving a piece back to its previous location, which is covered by the Two-Squares Rule.
Deadlocks occur when neither player is willing to advance the position. When a computer program plays a human, the human invariably will break any deadlocks, but computer programs playing each other might stall a game indefinitely. This rule eventually ends all deadlocks, although not efficiently.
