Here is a generalization of what I put above incase you don't want to make sense of it: (This only looks for Checkmate for the current turn not to a "n" depth)

      for (int i = 0; i < All of the possible moves this turn; i++) {

            int undo = The value of the board square (whatever piece is on that square) that might be captured;

            Do move "i"

            if (the opponent's King is attacked) {

                  build a list of all the possible moves the opponent would have

                  if (the opponent has no possible moves in response) {

                        Checkmate happened

                  }

If you want to look N moves ahead, then you probably want a recursive minimax tree search.  Some popular optimizations are alpha beta and negascout.

To be honest I would rather convert mine to be useable (learning experience)  but thank you for offering. I have a rough understanding of search tree pruning but I want to make a brute force search that looks at all possible moves first (I know that it will be slow). I understand theoretically what a brute force search should do but seem stuck in the code at the moment.

Here is the important part of how I plan to store the search tree:

int searchDepth = n (The number of moves to look ahead)

numPossible[maxPossibleMoves] (The length is set appropriately for the current node of the search tree)

possibleAction[searchDepth*2][numPossible[searchDepth]] (This let's me know if castling, en passant, or promotion happened mostly)

possibleLocation[searchDepth*2][numPossible[searchDepth] ] (Where the piece is before moving)

possibleTarget[searchDepth*2][numPossible[searchDepth] ] (Where the piece is after moving)

possibleType[searchDepth*2][numPossible[searchDepth] ] (What kind of piece it is. 1 is Pawn, 2 is Rook, ect)

What I had in mind was to use even numbers of searchDepth for the current player and odd numbers for the opponent during the search (for example if searchDepth is 0 it is the current turn, 1 is all the responses of the opponent one level deep into the tree, 2 would be all the responses to each of those for the current player, ect).

Is this enough information? I know that I need to convert undo (what stores captured pieces) into an array to keep track of captured pieces when I do and undo a move in the search tree (probably a double array actually that has the same method of storage, [searchDepth*2][numPossible[searchDepth]]).

Thank you for looking into this by the way, I know talking about sections of code without seeing the entire structure can be a pain.

Bear in mind that minimax is indeed a brute force search.  The usual way of implementing it is with a recursive function, however, not a series of loops.  It's much easier to implement that way, and doesn't require the complex arrays you are proposing.

hello,

interesting talk here.
I wanted to tell I made a chess visualization (without any ai)
in case you want to use it:

http://www.openprocessing.org/visuals/?visualID=31784

You can switch between different types of figures by cursor up and down.
You can also rotate the board (shift plus Mouse) - more information see below.

Did you read
http://en.wikipedia.org/wiki/Alpha-beta_pruning
and so forth?
There are some nice articles in Wikipedia such as
http://en.wikipedia.org/wiki/Computer_chess
and some nice external links such as
http://chess.verhelst.org/1997/03/10/search/

The general way is to do it recursive as jbum said.

If you don't want that and stay with a series of loops instead,
maybe you want to have a look at ArrayList. Here you don't have
to know the numbers of elements you are pushing in.
You can also have an array of arrayLists (the array being your depth
and the arraylist the possible moves in that depth maybe).

Greetings Chrisir 


P.S.
More information on http://www.openprocessing.org/visuals/?visualID=31784

Chess with 3 different sets of Figures. Runs only in Chrome (or offline).
Change the set of figures by Cursor Up.
Make a move by clicking startfield and then endfield. Click on the Board, not the figure.

Chess-set: http://www.mattclara.com/chessset.html - pretty slow, wait when made a move.
Bauhaus figures design by Bauhaus, build by myself.
Flat Figures by Wikimedia Commons.

Further Credits: http://code.google.com/p/saitoobjloader/
peasyCam (press and hold shift). shapes3D by Quark with picking. No checks if the move is valid etc. Computer doesn't know any rules.

I have a feeling I didn't set it up well for recursion. I am using arrays as I thought going into the environment that they would be significantly faster. Right now my method of searching for checkmate is an overly complicated series of for loops. In pseduo-code for checkmate in 1 or 2 it does this: