CSc 180
Intelligent Systems
TOURNAMENT RESULTS


2016

See the full event report here.

GAME: Trench Run
      This is a chess-like game with a sort of "Star Wars" theme, in which each player
      tries to capture the opponent's Death Star.  It is played on a 7x7 board, and each
      side starts with a set of pieces consisting of 1 Death Star, 2 walls, 4 tie-fighters
      (they move roughly like rooks), and 4 x-wings (they move roughly like bishops).
      Pieces can only move backwards if the move is a capture, and players cannot make
      two tie-fighter sideways moves in succession.  The Death Star can only be captured
      by a backwards move, and because of its initial position along a row of "wall"
      pieces, capturing it requires maneuvering along a back "trench", reminiscent of the
      climactic scene in the first Star Wars movie.  The initial position is:

             - T T - T T - 
             - - ~ * ~ - -
             X X - - - X X
             - - - - - - -
             x x - - - x x
             - - + @ + - -
             - t t - t t - 

      32 entries

      (0th place - "Tarkin" by Scott Gordon)
      1st place - "Mom" by James Womack
      2nd place - "HAL" by Oscar Solarzano
      3rd place - "Bane_AI" by Daniel Bergstrom

      In this tournament's 14-year history, this was the first time that the instructor's
      entry was the winner.  "Tarkin" was written in C++.

      "Mom", the 1st-place student entry, was also the very first champion written in C#.
      It utilized multi-threading, along with a sophisticated evaluation funtion, and a
      very nice-looking GUI.
download "Mom" (Windows executable)
      Here is a, strange, see-saw battle between "Mom" and "Tarkin", in which "Tarkin"
      takes a huge early lead after a weak opening by Mom.  But Mom fights back and
      Tarkin's position dissolves in amazing fashion.

     7  T - - - - T -  TARKIN vs MOM
     6  - X ~ * ~ - -  1.b3d5 b7b6 2.a3c5 c7a7 3.g3e5 f5d3 4.f3g4 b5c4 5.c5b6 a5b6
     5  - - - - x - -  6.f1f7 g7f7 7.b1b6 g5e3 8.d5c4 e3b6 9.c4d3 (see diagram)
     4  - - - - - - x  Tarkin is ahead by two x-wings, yet within a few moves, his
     3  - - - x - - -  position crumbles.  9...b6f2 10.g4f5 a7a5 11.f5g6 f7f3
     2  - - + @ + - -  12.d3e4 f2g1 13.c1g1 f3f2 14.e4d5 a5b5 15.g6f7 b5b4 16.g1c1
     1  - - t - - - t  ...f2f7 17.e5f6 f7f6 18.c1a1 f6f1 19.a1a2 f1d1 20.a2a3 d1d2
        _____________
        A B C D E F G
      
    

2015

See the full event report here.

GAME: GasTank Chess
      This is a chess-like game in which each player tries to capture the opponent's King.
      It is played on an 8x7 board, and each side starts with a set of pieces consisting
      of 1 king, 1 queen, 2 bishops, and 2 knights.  The queen moves like either a knight
      or a bishop.  Initially, every piece has a full tank of gas, equalling 3 moves.
      Each time a piece moves, its tank is reduced by 1.  If its tank reaches zero,
      it can no longer move.  But, when a piece captures another piece, its tank is
      "refilled" -- that is, it is brought back up to full.  Players ARE allowed to
      capture their own pieces.  The initial position is:

        -  -  B3 Q3 K3 B3 -  -
        -  -  -  N3 -  N3 -  -
        -  -  -  -  -  -  -  -
        -  -  -  -  -  -  -  -
        -  -  -  -  -  -  -  -
        -  -  -  n3 -  n3 -  -
        -  -  b3 q3 k3 b3 -  -

      35 entries

      1st place (tie) - "Diesel Wolf" by John Hill and "Buggy" by Scott Gordon
      3rd place - "Alter Ego" (Stephen Ly)
      4th place - "Sneaky" (Guraj Atwal)

      "Diesel Wolf" and "Buggy" were both written in C++ and utilized minimax, alpha-beta
      pruning, and iterative deepening and many other search techniques.  Diesel Wolf
      benefitted from a well-tuned and efficient evaluation function, whereas Buggy
      focused on additional search optimizations.
download "DieselWolf" (Windows executable - may require Visual C++ Redistributable)
      Here is a game between "Diesel Wolf" and "Buggy" that went all the way down to
      the very last possible move:

     7  -  -  -  -  K0 -  -  -  DIESEL WOLF vs. BUGGY
     6  -  -  -  -  -  -  -  -  1.c1b2 c7a5 2.b2c3 d7b6 3.c3f6 e7f6 4.f2g4 f6e7
     5  -  -  -  -  -  -  -  -  5.d1f3 f7a2 6.g4e5 e7f6 7.f3g4 f6e7 8.g4e5 a5d2
     4  -  -  B3 -  -  -  -  -  9.e1d2 d6c4 10.f1c4 b6c4 11.e5c4 a2c4 (see diagram)
     3  -  -  -  -  -  -  -  -  now both the white king and black bishop have 3 moves
     2  -  -  -  K3 -  -  -  -  in the tank. But the white king must move first.
     1  -  -  -  -  -  -  -  -  12.d2e1 c4b3 13.e1f1 b3a2 14.f1e1 a2b1 and black wins.
        ______________________
        A  B  C  D  E  F  G  H
    

2014

See the full event report here.

GAME: Refusal
      This is based on a chess variant invented by Fred Galvin, which he
      called "Refusal Chess".  In refusal, when someone makes a move, the
      opponent has the option of "refusing" the move.  If a move is refused,
      a different move must be played - that one must be accepted.
      This version of Refusal is played on a 5x8 board containing pawns,
      knights, rooks, and kings.  Unlike regular chess, pieces can only
      move forward, pawns don't have a double-move option, kings can only
      move if it is a capture and are confined to the back rank, and rooks
      are either "left" or "right", meaning they can only move one direction
      when moving laterally.  The initial position is as follows:

        R - - K L
        - - - - -
        N P P P N
        - - - - -
        - - - - -
        n p p p n
        - - - - -
        r k - - l

      25 entries

      1st place - "Nibbles" by Ben Botto
      2nd place (tie) - "Minimaxploitation" (Timothy Shea)
                    and "Intuition" (Nick Clayton)
      4th place - "Rocky 4" (Ethan Weidman)

      "Nibbles" was written in C++ and utilized minimax, alpha-beta
      pruning, iterative deepening, and many other search techniques.
      What set it apart was its launching of predictive threads to think
      on the opponent's time, and its superior evaluation function.
download "Nibbles"(32-bit)
download "Nibbles"(64-bit)
     Here is a dominant win by "Nibbles" over the instructor's program:

      8  R - - K L    DECIDER vs NIBBLES
      7  - - - - -    1.a6c4(r) e6c5, a3c4(r) e3c4 2.a6b4, c3b4 3.c5a4, c4d6
      6  - P P n -    (see diagram - Decider thinks it has attacking chances,
      5  - - - - -    but Nibbles is already in control) 4.a4c3(r) a8a7, d6e8
      4  N p - - -    5.a7d7, b3a4(r) a3c4 6.a4c3(r) a4b2, c4d6 7.d7d6(r)
      3  n p - p -    b6b5, a1a7 (Nibbles announces that a win is guaranteed)
      2  - - - - -    8.d7d6(r) c6c5, a7d7(r) b4c5 9.d7d6(r) b5b4, a7d7(r)
      1  r k - - l    e1e2 10.d7d6(r) b2d1, a7d7 11.d8e8, d6e8 winning.
         _________
         a b c d e
    

2013

See the full event report here.

GAME: Borgo Pass
      This is a chess-like game with a vampire theme, in which each player
      takes turns moving their pieces on a 7x8 board, trying to capture
      the opponent's vampire.  Other pieces include bats, wolves, and
      mirrors.  Wolves move like knights in regular chess, bats move like
      bishops, and the vampire can move in either manner.  Mirrors are
      limited in their movement, but can capture any vampire on the same
      vertical column.  The initial position is:

        B M - V - M B
        W W - - - W W
        - - - - - - -
        - - - - - - -
        - - - - - - -
        - - - - - - -
        w w - - - w w
        b m - v - m b

      28 entries

      1st place - "Ramathorne 3" by Matt Rojas
      2nd place - "Honest Abe" by Nick Pearson
      3rd place - "Adamas" by Kyle Matz, and "Van Helsing" by Manuel Sabin

      "Ramathorne 3" was written in C++, utilizing minimax and alpha-beta
      pruning, iterative deepening, bitboards, history tables, multithreading,
      and a clever prediction mechanism to search 8 or 9 plies at each move.
      Given that Borgo Pass has a branching factor approaching that of chess
      - around 30 - "Ramathorne 3" is thus able to analyze on the order of
      two billion moves within the 5-second time limit. 
download "Ramathorne 3"
(Windows - requires Visual C++ 2012 32-bit runtime)
      Here is an exciting win by "Ramathorne 3" over the instructor's program:

      8  - b - - - M -   RAMATHORNE3 vs ORLOCK
      7  - - - - - - -   1.f2d3 b7a5 2.g1b6 (the bat is defended by the mirror)
      6  - - - - W - -   d8e7 3.f1e1 e7g5 4.g2e3 f7d6 5.b6a7 g8b3 6.d1e2 a8f3
      5  W - - - - V -   7.e2g3 d6e4 8.g3e1 (capturing its own piece to survive)
      4  w - - - W - -   b3a2 9.b2a4 g7e6 10.a7b8 a2b1 (see diagram - at first
      3  - - - w w B -   Orlock appears to be ahead, but actually it is already
      2  - - - - - - -   running out of moves) 11.d3f4 a5b3 (up to now, every
      1  b B - - v - -   one of Orlock's moves has been predicted by Ramathorne)
                         12.a1c3 e6c5 13.a4c5 b3c5 14.c3e5 c5d3 15.e1f3 d3e5
                         16.b8e5 e4g3 17.e3d5 f8e8 18.d5c7 g3e2 19.f4e2 winning.
    

2012

See the full event report here.

GAME: PaoQi
      This game is inspired by "Chinese Chess", or "Xiangqi", considered
      by many to be the most popular board game in the world.  PaoQi is
      a considerably simpler game.  Players take turns moving their pieces
      on an 7x7 board, and try to capture the opponents' king.  Other pieces
      include pawns, helpers, and cannons.  The kings and helpers are
      confined to a 6-quare region called the "palace" (similar to Xiangqi).
      Pawns move and capture in a manner similar to western chess.  The
      cannon moves like a "rook" in western chess, but captures only by
      jumping over another piece, and only when it is "loaded" (defined as
      having just moved sideways).  The initial position is:

        C C H K H C C
        - P P P - - -
        - - - - - - -
        - - - - - - -
        - - - - - - -
        - - - p p p -
        c c h k h c c

      20 entries

      1st place - "Batty" by Mike Vollmer
      2nd place - "Lion" by Josh Eilers
      3rd place - "TuoLaJi" by Scott Gordon
      4th place - "Prime" by Chris Liberatore

      "Batty" was written in C, utilizing minimax and alpha-beta pruning,
      iterative deepening, sophisticated move ordering, killer move heuristic,
      and most notably, transposition tables with Zobrist key hashing to
      search 10+ plies deep right from the opening position.  
download "Batty"
      Here is a wild tactical win by "Batty" over the instructor's program:

      7  C - c*k h - -   BATTY vs. TUOLAJI
      6  - - h p - - -   1.e2e3 f7f5 2.d2d3 g7f7 3.a1a4 f5d5 4.e1d2 a7a5
      5  - p - c*- P -   5.b1a1 a5b5 6.f2f3 b5b4 7.f1e1 c6c5 8.a4a6 c5c4
      4  - - - C*c - -   9.f3f4 b4b3 10.a6a7 c7c6 11.a1a2 c4c3 12.a2a4 f7f6
      3  - c - P P - -   13.e1e2 f6e6 14.a4d4 c3c2 15.c1xc2 e6e4 16.f4f5
      2  - - H H - C*-   (note that if 16.d3xe4, then 16...b3d3 wins because
      1  - - - K C*- -   kings can only move if its a capture) 16...b7c7
         A B C D E F G   17.g1e1 b6b5 18.e2f2 (see diagram - Batty reports
                         here that its opponent can win, but TuoLaJi misses
                         the winning line) 18...b5b4 19.e1xe4 b3a3 20.d4xd6
               e7xd6 21.e4c4 c7xc4 (Batty is behind by a cannon, but has
               calculated a guaranteed victory) 22.e3e4 b4b3 23.e4e5 b3xc2
               24.d1xc2 c4g4 25.e5e6 a3a2 26.e6xd7 winning the king.

      The second game in this match was even crazier:

      7  - - h k - - -   TUOLAJI vs. BATTY
      6  c - - - h - -   1.b1b3 f7f5 2.g1g4 f5f4 3.e2e3 g7g5 4.b3d3 g5d5
      5  - - p C P - -   5.e3e4 (PaoQi is a very tricky game. Presumably
      4  - - P c c*- C   e3xf4 falls to a7a3 followed by c6-c5-c4) c6c5
      3  - - - - - P -   6.c1c2 d5d4 7.a1c1 d6d5 8.e4e5 e7e6 9.e1e2 a7a6
      2  - - H - H C*-   10.f2f3 a6a5 11.f1g1 a5a4 12.g1g2 a4c4 (the game
      1  - - - K - - -   has been pretty quiet so far - now things get crazy)
         A B C D E F G   13.c1xc4 b7a7 14.d3xd5 (blacks cannon on d4 isn't
                         loaded, so this move appears safe. TuoLaJi appears
                         to be winning, but Batty predicts victory) a7a6
               15.d2d3 b6b5 16.g2f2 b5xc4 17.d3xc4 f4e4 (see diagram; an
               amazing move that appears to simply sacrifice a canon for
               nothing. But white doesn't capture - the calculations are
               too difficult to enumerate here) 18.f3f4 a6c6 19.f4f5 d4d3
               20.f5xe6 d7xe6 21.f2f3 c6xc4 (and now the combination that
               white was trying to fend off is apparent - and there is no
               defense) 22.f3e3 c4d4 23.g4f4 d4xd1 winning the king.
    

2010

See the full event report here.

GAME: SCHMESH
      This game is inspired by the 1960s Milton Bradley game of "Smess",
      where a piece's mobility is determined by what square it is on.
      Schmesh uses an 8x5 board, players take turns moving their pieces
      according to rules somewhat like chess.  Each time a player moves, the
      piece that just moved changes to another type of piece, depending on the
      row that the piece lands on.  Rows 1-8 correspond to the following chess
      pieces: rook, pawn, knight, bishop, bishop, knight, pawn, rook.  Pieces
      are a bit simplified: rooks can only move one square side-to-side (and
      only to capture), pawns can only move forward one square diagonal, bishops
      and knights can only move forward, kings move like rooks.  It is LEGAL
      to capture your own pieces.  A player wins by capturing the opponent's
      king, or if the opponent cannot move.  The initial position is:

        - R K R -
        P P P P P
        - - N - -
        - - - - -
        - - - - -
        - - n - -
        P p p p P
        - r k r -

      26 entries.

      1st place - "Chubs" by Mitch Heer
      2nd place - "Numbskull" by Scott Gordon
      3rd place - "a.out" by Michael Braden
      4th place - "Saternine" by David Bettencourt

      "Chubs" was written in Java, utilizing minimax with alpha-beta
      pruning, iterative deepening, aspiration windows, Killer Move
      heuristic,  and sophisticated move-ordering techniques. 
download "Chubs"
      Here is a solid win by "Chubs" over the instructor's program:

      8  - R K R -   CHUBS vs. NUMBSKULL
      7  - - p - -   1.e2d3 d7e6 2.b2a3 e7d6 3.a2b3 a7b6 4.b3c5 e6c5
      6  - - - - -   5.d3c5 c6b4 6.a3b5 d6b5 7.c3b5 b4d2 8.c1b1 b7a6
      5  - - b - -   9.b5a6 d2c1 10.b1c1 b6a4 11.a6c7 (removing
      4  B - - - -   the king's ability to capture its own rooks,
      3  - - - - -   and therefore its ability to flee) - see diagram -
      2  - - p - -   11...a4c2 12.c5d6 c2d1 13.d6c8 wins.
      1  - - k r -
         A B C D E

    

2009

See the full event report here.

GAME: CATNAP
      7x5 board, players take turns moving their pieces according to rules
      similar to chess.  A player wins by capturing the opponents' king,
      or if the opponent cannot move. The name "Catnap" refers to the
      unusual rule that the king can never move twice in succession.
      That is, the king is like a typical housecat - whenever it exerts
      itself, it need to immediately take a nap before it can move again.
      The other pieces are 3 pawns, 2 knights, and 2 bishops.  Pieces can
      only move forwards, but they are allowed to capture either backwards
      or forwards.  Pawns move as in regular chess (there is no 2-move rule),
      and if they reach the back rank they are stuck and can no longer move.
      The starting position is as follows:

        B B K N N
        - P P P -
        - - - - -
        - - - - -
        - - - - -
        - p p p -
        n n k b b

      20 entries.

      1st place (tie) - "Hairball" by Levi Stanley
                        "ONYX" by Josh Christanelli
      3rd place       - "Chairman Meow" by Scott Gordon

      Both "Hairball" and "ONYX" were written in C++, utilizing minimax
      with alpha-beta pruning, iterative deepening, and sophisticated
      move-ordering techniques.  "Hairball" used bitboards, "ONYX" used a
      variety of cross-referencing tables.  Both searched over 10 plies deep.
    
download "ONYX"
      Here is a quick win by ONYX over the instructor's program:

      7  B - - N N   ONYX vs. Chairman Meow
      6  b - K - -   1.d2d3 b7a6 2.d3d4 c7b7 3.c2c3 b6b5 4.b2b3 b7c7
      5  - - p P -   5.b3b4 d6d5 6.a1b3 c7b6 7.b1a3 (in a nearly
      4  - - - p -   symmetrical position, Meow is already in trouble)
      3  P n p - -   ...c6c5 8.b4c5 b6c7 9.d1e2 b5b4 10.e2a6 b4a3
      2  - - - - -   (see diagram) 11.c3c4! (a devastating move)
      1  - - k b -   ...a3a2 12.e1a5 d7b6 13.c5b6 a7b6 14.a5b6 c7b6
         A B C D E   (other moves also lose) 15.c4c5 e7c6 (remember,
                     the king can't move twice in a row!) 16.c5b6 wins.

    

2008

See the full event report here.

GAME: SIDESTEP
      6x5 board, players take turns moving their pieces according to rules
      similar to chess.  A player wins by capturing the opponents' king,
      or if the opponent cannot move. The name "sidestep" refers to how
      the kings can move -- they are limited to a simple sidestepping move
      in one direction only.  The other pieces can only move in the forward
      direction (except when capturing which can be done backwards as well),
      and consist of soldiers (similar to the "queen" in regular chess) and
      pawns. Pawns are the same as in regular chess, but when they reach
      the back row they are stuck and can never move again.  Starting position:

      6  K S S S S  computer
      5  P P P P P
      4  - - - - -
      3  - - - - -
      2  p p p p p
      1  s s s s k  human
      ------------
         A B C D E

      26 entries.

      1st place - "Time Bender" by Tim Bender
      2nd place - "Surgeon" by Scott Gordon
      3rd place - "Fiend" by Sterling Schulkins

      Time Bender was written in Java, and was the first time that a program
      written in Java has won this event.  Time Bender utilized minimax with
      alpha-beta pruning, iterative deepening, and a unique variation on
      history tables that allowed it to search 8-10 plies deep within the
      5 seconds allotted per move.
download "Time Bender"
      Here one of "Time Bender"'s wins:

      6  K S - S -    Time Bender vs. Fiend
      5  P P - - -    1.b2b3 d5d4 2.c2c3 c6d5 3.e2e3 d4e3 4.d2d3 e5e4
      4  - - P - S    5.c1e3 e4d3 6.d1d2 e5e4 7.e3e4 e6e4 8.e1d1 c5c4
      3  - p p P -    (hard to imagine that Time Bender has the advantage,
      2  p - - s -    but watch what happens) 9.b3c4 e4e2 10.d1c1 b5c4
      1  s s - k -    11.b1b6 a6b6 12.a1b2 d6b4 13.c3b4 e2d1 
         A B C D E    14.b2d4 b6c6 15.b4b5 d1d2 16.b5c6 winning

    

2007

See the full event report here.

GAME: LEMMING CHESS
      8x4 board, players take turns moving their pieces according to standard
      rules for chess pieces (pawn, knight, bishop).  However, pieces can only
      move forward, unless they are capturing, wherein they may capture either
      forwards or backwards.  Capture is compulsary.  Pawns become immobile
      when they reach the back rank.  A player wins if he has no legal moves.

        8  N B B N
        7  P P P P
        6  - - - -
        5  - - - -
        4  - - - -
        3  - - - -
        2  p p p p
        1  n b b n
           A B C D

      17 entries.

      1st place - "Judgment" by Andrew Redden.
      2nd place - "Know Hao" by Hao Le
      3rd place - "Pwnage!!1" by Derek Goering

      "Judgment" used iterative deepening and transposition tables with
      Zobrist key hashing to search between 12 and 22 plies deep.  It won
      a close contest, scoring 15-5 and was the clear winner of the final
      round robin, with a score 4-2.
    
download "Judgment"
      Here is one of "Judgment"'s solid wins:

      8  - - - N       Pwnage!!1 vs. Judgment
      7  - P N B       1.a2a3 a7a6, 2.a3a4 d7d6, 3.b2b3 c7c6, 4.d1c3 a8c7
      6  P p - P       5.c3d5 c6d5, 6.a4a5 b8a7, 7.b3b4 a7b6, 8.a5b6 c8d7
      5  - - - P       (see position - despite material equality, Judgment
      4  - p - -       has already predicted victory)  9.b6c7 d7b5, 10.c7d8
      3  - - - -       a6a5, 11.b4a5 b7b6, 12.a5b6 b5d3, 13.c2d3 d5d4, 14.b6b7
      2  - - p p       d6d5, 15.b7b8 Judgment has no move and therefore wins.
      1  n b b - 
         A B C D

    

2006

See the full event report here.

GAME: RABBIT RACE
      8x5 board, players take turns moving their "rabbits" one square
      forward (straight or diagonal). Captures are jumps similar to checkers,
      but jumping directly forward is also allowed.  Jumping is compulsary.
      The first player to get a piece in the "rabbit hole" in the middle of
      the opposite side of the board, is the winner.  The starting position is:

        8  - - * - -
        7  X X X X X
        6  X X X X X
        5  - - - - -
        4  - - - - -
        3  O O O O O
        2  O O O O O
        1  - - * - -
           A B C D E

      26 entries

      1st place:        "Prophet" (Phuong Nguyen)
      2nd place (tie):  "Sgt Schultz" (Jake Henriet) and "Harvey" (Scott Gordon)
      4th place:        "Velvetine" (Christian Burns)

      "Prophet" (C++) used iterative deepening, killer move, and quiescent extensions
      to search between 11 and 20 plies deep.  More importantly, it had a terrific
      evaluation function.  It won every game it played, scoring a flawless 24-0.
    
download "Prophet"
(note - only runs on the machines in RVR-5029)
      Here is one of "Prophet"'s nifty wins:

      8  - - * - -      Harvey vs. Prophet
      7  - - X X -      1.a6b5 d3c4, 2.b5d3 d2d4, 3.b6a5 a3a4,
      6  O - - - -      4.a5a3 a2a4, 5.c6b5 a4c6, 6.b7d5 b3a4,
      5  - - - - X      7.d5d3 e2c4, 8.e6d5 c4e6, 9.e7e5 a4b5,
      4  - - X - -      10.d6d5 c3c4, 11.d5b3 c2a4, 12.a7a6 a4a5
      3  - - - - O      13.a6c4 a5a6 and there is no stopping
      2  - O - - -       the rabbit on A6.
      1  - - * - -
         A B C D E

    

2005

See the full event report here.

GAME: MINI-CHECKERS
      6x8 board, players take turns moving their "checker pieces" one
      diagonal square at a time.  Capturing by jumping is compulsary.
      No multiple jumps.  When a piece reaches the back rank, it can no
      longer move.  A player can win either by (a) getting two checkers
      to the back rank, or (b) the opponent is unable to move.
      The initial position is:

         1 X - X - X - X -
         2 - X - X - X - X
         3 - - - - - - - -
         4 - - - - - - - -
         5 O - O - O - O -
         6 - O - O - O - O
           A B C D E F G H

      16 entries

      1st place:   "Sleeper" (Hong Nguyen)
      2nd place:   "Slasher" (Deixong Zhang)
      3rd place:   "Snow Princess" (Alex Loret deMola)
      4th place:   "Bitwise" (Tyler Karaszewski)

      "Sleeper" (C++) used a 12+ ply search with iterative deepening and killer heuristic.
      "Bitwise" used transposition tables and bitmaps and searched even deeper.

      Here's an example of "Sleeper" winning a very close one:

      1  - - O - - - - -     Sleeper vs. Bitwise
      2  - - - - - O - -     1.h2g3 c5d4, 2.b2c3 d4b2, 3.a1c3 g5f4,
      3  - - - - - - - -     4.g3h4 b6c5, 5.d2e3 f4d2, 6.c1e3 e5d4,
      4  - - - - - - - -     7.c3e5 d6f4, 8.e3g5 h6f4, 9.f2e3 f4d2,
      5  - - - - - - - -     10.e1c3 c5d4, 11.c3e5 f6d4, 12.g1f2 a5b4,
      6  - - - X - X - -     13.f2g3 b4c3, 14.g3f4 c3d2, 15.f4e5 d4e3,
         A B C D E F G H     16.h4g5 e3f2, 17.g5f6 d2c1, 18.e5d6 wins
    

2004

See the full event report here.

GAME: PAWNSTOP
      6x8 board, players take turns moving their pawns forward one square
      at a time. As in regular chess, they capture on the diagonal.  When
      a pawn reaches the last rank, it can no longer move.  When a player
      has no more moves, he/she loses.  The starting position is:

               1  - - - - - - - -
               2  X X X - X X X X
               3  - - - - - - - -
               4  - - - - - - - -
               5  O O O O - O O O
               6  - - - - - - - -
                  A B C D E F G H

      20 entries

      1st place:        "Dead End" (Jason Chang)
      2nd place(tie):   "Hannah" (Joshua Bettencourt) and "Muncher" (Scott Gordon)
      4th place:        "Lil'Brudder" (Kevin Hjelden)
    
download "Dead End"
      "Dead End" (C++) used a 10 ply search and a sophisticated eval function.
      "Lil'Brudder" used transposition tables and searched even deeper.

      Here's an example of "Dead End"'s efficient style of play:

      1  - - - - - - - -     Hannah vs. Dead End
      2  O - - - - - - -     1.a2a3 h5h4, 2.b2b3 g5g4, 3.c2c3 f5f4,
      3  - - - - O - X -     4.g2g3 h4g3, 5.f2g3 f4g3, 6.h2g3 a5a4,
      4  - - O - - - O -     7.b3b4 c5b4, 8.a3b4 a4a3, 9.e2e3 a3a2,
      5  - X - - - - - -     10.c3c4 b5c4, 11.e3e4 d5e4 12.b4b5 e4e3 and wins.
      6  - - - - - - - -
         A B C D E F G H
      
    

2003

See the full event report here.

GAME: 4-IN-A-ROW
      (same as in 2002 below)

      33 entries

      1st place:        "Headstrong" (Jeb Crouson)
      2nd place (tie):  "Evolution" (Adam Ruggles) and "Dark Cloud 2" (Scott Gordon)
      4th place:        "Hello World" (Robert Lapanja)
    
download "Headstrong"
      "Headstrong" was written in C, using iterative deepening, history tables.
      "Hello World" used bitmaps and searched deeper, but had a bug.

      I took the liberty of playing a 2-game match between "Headstrong" and
      the 2002 winner "Mr.X".  Amazingly, both games ended in a draw!
      Here is one of their games - quite a seesaw battle:

      Headstrong vs. Mr.X -- 1.d5 c5 2.d4 d3 3.c4 b4 4.c3 b3 5.e4 f4
      6.d6 d7 7.c2 c1 8.b2 d2 9.c6 e6 10.b6 a6 11.b5 d1 12.b7 b8
      13.b1 c8 14.d8 e7 15.f7 f3 16.f2 a5 17.a7 a8 18.e5 c7 19.f6 f5
      20.f1 e1 21.g3 e3 22.g8 e2 23.h6 e8 24.h5 h4 25.a4 g4 26.a3 g5
      27.g6 h3 28.f8 h2 29.h1 g2 30.h7 h8 31.a2 a1 32.g7 g1 DRAW

    

2002

See the full event report here.

GAME: 4-IN-A-ROW
      8x8 board, players take turns placing a piece on any square.
      First player to get 4 in a row, diagonals NOT counting, wins.
      Game unsolved, but probably a win for the first player.

      21 entries

      1st place:        "Mr. X" (Jonathan Pullen)
      2nd place (tie):  "Lien" (Jason Lien) and "Dark Cloud" (Scott Gordon)
      4th place:        "Holden" (Meg Holden)

      "Mr.X" was written in C++, using iterative deepening and history tables.

      Here is an interesting win by Mr.X over an experimental version
      of DarkCloud:

        1 2 3 4 5 6 7 8     DarkCloud3 vs. Mr.X
      A - - - - - - - -        1. e5 d5
      B - - O - - - - -        2. e4 e3
      C - - O - - - - -        3. f4 d4
      D - X O O O X - -        4. e6 e7
      E - - O X X X O -        5. g4 h4
      F - - X X - - - -        6. d6 d3
      G - - - X - - - -        7. d2 c3
      H - - - O - - - -        8. f3 b3wins